Computer architecture for emulating drift-between string correlithm objects in a correlithm object processing system

ABSTRACT

A device that includes a node engine configured to define a number of child correlithm objects for a string correlithm object. The node engine is further configured to set a starting correlithm object as a first parent correlithm object and set an ending correlithm object as a second parent correlithm object. The node engine is further configured to randomly select a correlithm object less than the standard distance away from the first parent correlithm object, define the selected correlithm object as a child correlithm object, and link the child correlithm objects with the first parent correlithm object. The node engine is further configured to randomly select a correlithm object less than the standard distance away from the second parent correlithm object, define the selected correlithm object as a child correlithm object, and link the child correlithm objects with the second parent correlithm object.

TECHNICAL FIELD

The present disclosure relates generally to computer architectures foremulating a processing system, and more specifically to computerarchitectures for emulating a correlithm object processing system.

BACKGROUND

Conventional computers are highly attuned to using operations thatrequire manipulating ordinal numbers, especially ordinal binaryintegers. The value of an ordinal number corresponds with its positionin a set of sequentially ordered number values. These computers useordinal binary integers to represent, manipulate, and store information.These computers rely on the numerical order of ordinal binary integersrepresenting data to perform various operations such as counting,sorting, indexing, and mathematical calculations. Even when performingoperations that involve other number systems (e.g. floating point),conventional computers still resort to using ordinal binary integers toperform any operations.

Ordinal based number systems only provide information about the sequenceorder of the numbers themselves based on their numeric values. Ordinalnumbers do not provide any information about any other types ofrelationships for the data being represented by the numeric values suchas similarity. For example, when a conventional computer uses ordinalnumbers to represent data samples (e.g. images or audio signals),different data samples are represented by different numeric values. Thedifferent numeric values do not provide any information about howsimilar or dissimilar one data sample is from another. Unless there isan exact match in ordinal number values, conventional systems are unableto tell if a data sample matches or is similar to any other datasamples. As a result, conventional computers are unable to use ordinalnumbers by themselves for comparing different data samples and insteadthese computers rely on complex signal processing techniques.Determining whether a data sample matches or is similar to other datasamples is not a trivial task and poses several technical challenges forconventional computers. These technical challenges result in complexprocesses that consume processing power which reduces the speed andperformance of the system. The ability to compare unknown data samplesto known data samples is crucial for many security applications such asface recognition, voice recognition, and fraud detection.

Thus, it is desirable to provide a solution that allows computingsystems to efficiently determine how similar different data samples areto each other and to perform operations based on their similarity.

SUMMARY

Conventional computers are highly attuned to using operations thatrequire manipulating ordinal numbers, especially ordinal binaryintegers. The value of an ordinal number corresponds with its positionin a set of sequentially ordered number values. These computers useordinal binary integers to represent, manipulate, and store information.These computers rely on the numerical order of ordinal binary integersrepresenting data to perform various operations such as counting,sorting, indexing, and mathematical calculations. Even when performingoperations that involve other number systems (e.g. floating point),conventional computers still resort to using ordinal binary integers toperform any operations.

Ordinal based number systems only provide information about the sequenceorder of the numbers themselves based on their numeric values. Ordinalnumbers do not provide any information about any other types ofrelationships for the data being represented by the numeric values suchas similarity. For example, when a conventional computer uses ordinalnumbers to represent data samples (e.g. images or audio signals),different data samples are represented by different numeric values. Thedifferent numeric values do not provide any information about howsimilar or dissimilar one data sample is from another. Unless there isan exact match in ordinal number values, conventional systems are unableto tell if a data sample matches or is similar to any other datasamples. As a result, conventional computers are unable to use ordinalnumbers by themselves for comparing different data samples and insteadthese computers rely on complex signal processing techniques.Determining whether a data sample matches or is similar to other datasamples is not a trivial task and poses several technical challenges forconventional computers. These technical challenges result in complexprocesses that consume processing power which reduces the speed andperformance of the system. The ability to compare unknown data samplesto known data samples is crucial for many applications such as securityapplication (e.g. face recognition, voice recognition, and frauddetection).

The system described in the present application provides a technicalsolution that enables the system to efficiently determine how similardifferent objects are to each other and to perform operations based ontheir similarity. In contrast to conventional systems, the system usesan unconventional configuration to perform various operations usingcategorical numbers and geometric objects, also referred to ascorrelithm objects, instead of ordinal numbers. Using categoricalnumbers and correlithm objects on a conventional device involveschanging the traditional operation of the computer to supportrepresenting and manipulating concepts as correlithm objects. A deviceor system may be configured to implement or emulate a special purposecomputing device capable of performing operations using correlithmobjects. Implementing or emulating a correlithm object processing systemimproves the operation of a device by enabling the device to performnon-binary comparisons (i.e. match or no match) between different datasamples. This enables the device to quantify a degree of similaritybetween different data samples. This increases the flexibility of thedevice to work with data samples having different data types and/orformats, and also increases the speed and performance of the device whenperforming operations using data samples. These technical advantages andother improvements to the device are described in more detail throughoutthe disclosure.

In one embodiment, the system is configured to use binary integers ascategorical numbers rather than ordinal numbers which enables the systemto determine how similar a data sample is to other data samples.Categorical numbers provide information about similar or dissimilardifferent data samples are from each other. For example, categoricalnumbers can be used in facial recognition applications to representdifferent images of faces and/or features of the faces. The systemprovides a technical advantage by allowing the system to assigncorrelithm objects represented by categorical numbers to different datasamples based on how similar they are to other data samples. As anexample, the system is able to assign correlithm objects to differentimages of people such that the correlithm objects can be directly usedto determine how similar the people in the images are to each other. Inother words, the system is able to use correlithm objects in facialrecognition applications to quickly determine whether a captured imageof a person matches any previously stored images without relying onconventional signal processing techniques.

Correlithm object processing systems use new types of data structurescalled correlithm objects that improve the way a device operates, forexample, by enabling the device to perform non-binary data setcomparisons and to quantify the similarity between different datasamples. Correlithm objects are data structures designed to improve theway a device stores, retrieves, and compares data samples in memory.Correlithm objects also provide a data structure that is independent ofthe data type and format of the data samples they represent. Correlithmobjects allow data samples to be directly compared regardless of theiroriginal data type and/or format.

A correlithm object processing system uses a combination of a sensortable, a node table, and/or an actor table to provide a specific set ofrules that improve computer-related technologies by enabling devices tocompare and to determine the degree of similarity between different datasamples regardless of the data type and/or format of the data samplethey represent. The ability to directly compare data samples havingdifferent data types and/or formatting is a new functionality thatcannot be performed using conventional computing systems and datastructures.

In addition, correlithm object processing system uses a combination of asensor table, a node table, and/or an actor table to provide aparticular manner for transforming data samples between ordinal numberrepresentations and correlithm objects in a correlithm object domain.Transforming data samples between ordinal number representations andcorrelithm objects involves fundamentally changing the data type of datasamples between an ordinal number system and a categorical number systemto achieve the previously described benefits of the correlithm objectprocessing system.

Using correlithm objects allows the system or device to compare datasamples (e.g. images) even when the input data sample does not exactlymatch any known or previously stored input values. For example, an inputdata sample that is an image may have different lighting conditions thanthe previously stored images. The differences in lighting conditions canmake images of the same person appear different from each other. Thedevice uses an unconventional configuration that implements a correlithmobject processing system that uses the distance between the data sampleswhich are represented as correlithm objects and other known data samplesto determine whether the input data sample matches or is similar to theother known data samples. Implementing a correlithm object processingsystem fundamentally changes the device and the traditional dataprocessing paradigm. Implementing the correlithm object processingsystem improves the operation of the device by enabling the device toperform non-binary comparisons of data samples. In other words, thedevice is able to determine how similar the data samples are to eachother even when the data samples are not exact matches. In addition, thedevice is able to quantify how similar data samples are to one another.The ability to determine how similar data samples are to each other isunique and distinct from conventional computers that can only performbinary comparisons to identify exact matches.

The problems associated with comparing data sets and identifying matchesbased on the comparison are problems necessarily rooted in computertechnologies. As described above, conventional systems are limited to abinary comparison that can only determine whether an exact match isfound. Emulating a correlithm object processing system provides atechnical solution that addresses problems associated with comparingdata sets and identifying matches. Using correlithm objects to representdata samples fundamentally changes the operation of a device and how thedevice views data samples. By implementing a correlithm objectprocessing system, the device can determine the distance between thedata samples and other known data samples to determine whether the inputdata sample matches or is similar to the other known data samples. Inaddition, the device is able to determine a degree of similarity thatquantifies how similar different data samples are to one another.

Certain embodiments of the present disclosure may include some, all, ornone of these advantages. These advantages and other features will bemore clearly understood from the following detailed description taken inconjunction with the accompanying drawings and claims.

BRIEF DESCRIPTION OF THE DRAWINGS

For a more complete understanding of this disclosure, reference is nowmade to the following brief description, taken in connection with theaccompanying drawings and detailed description, wherein like referencenumerals represent like parts.

FIG. 1 is a schematic view of an embodiment of a special purposecomputer implementing correlithm objects in an n-dimensional space;

FIG. 2 is a perspective view of an embodiment of a mapping betweencorrelithm objects in different n-dimensional spaces;

FIG. 3 is a schematic view of an embodiment of a correlithm objectprocessing system;

FIG. 4 is a protocol diagram of an embodiment of a correlithm objectprocess flow;

FIG. 5 is a schematic diagram of an embodiment a computer architecturefor emulating a correlithm object processing system;

FIG. 6 is a schematic diagram of an embodiment of a device implementingstring correlithm objects for a correlithm object processing system;

FIG. 7 is a schematic diagram of another embodiment of a deviceimplementing string correlithm objects for a correlithm objectprocessing system;

FIG. 8 is a flowchart of an embodiment of a process for emulating stringcorrelithm objects for a correlithm object processing system;

FIG. 9 is a schematic diagram of another embodiment of a deviceimplementing string correlithm objects for a correlithm objectprocessing system;

FIG. 10 is a flowchart of another embodiment of a process for emulatingstring correlithm objects for a correlithm object processing system;

FIG. 11 is a schematic diagram of an embodiment of a quantizer for acorrelithm object processing system;

FIG. 12 is a flowchart of another embodiment of a process for emulatinga quantizer for a correlithm object processing system;

FIG. 13 is an embodiment of a graph of a probability distribution formatching a random correlithm object with a particular correlithm object;

FIG. 14 is a schematic diagram of an embodiment of a device implementinga correlithm object core for a correlithm object processing system;

FIG. 15A is a flowchart of an embodiment of a process for emulating acorrelithm object core for a correlithm object processing system;

FIG. 15B is a flowchart of another embodiment of a process for emulatinga correlithm object core for a correlithm object processing system;

FIG. 16 is an embodiment of a graph of probability distributions foradjacent root correlithm objects;

FIG. 17 is another embodiment of a graph of probability distributionsfor adjacent root correlithm objects; and

FIG. 18 is a flowchart of an embodiment for refining correlithm objectscores in a correlithm object processing system.

DETAILED DESCRIPTION

FIGS. 1-5 generally describe various embodiments of how a correlithmobject processing system may be implemented or emulated in hardware,such as a special purpose computer.

FIG. 1 is a schematic view of an embodiment of a user device 100implementing correlithm objects 104 in an n-dimensional space 102.Examples of user devices 100 include, but are not limited to, desktopcomputers, mobile phones, tablet computers, laptop computers, or otherspecial purpose computer platforms. The user device 100 is configured toimplement or emulate a correlithm object processing system that usescategorical numbers to represent data samples as correlithm objects 104in a high-dimensional space 102, for example a high-dimensional binarycube. Additional information about the correlithm object processingsystem is described in FIG. 3. Additional information about configuringthe user device 100 to implement or emulate a correlithm objectprocessing system is described in FIG. 5.

Conventional computers rely on the numerical order of ordinal binaryintegers representing data to perform various operations such ascounting, sorting, indexing, and mathematical calculations. Even whenperforming operations that involve other number systems (e.g. floatingpoint), conventional computers still resort to using ordinal binaryintegers to perform any operations. Ordinal based number systems onlyprovide information about the sequence order of the numbers themselvesbased on their numeric values. Ordinal numbers do not provide anyinformation about any other types of relationships for the data beingrepresented by the numeric values, such as similarity. For example, whena conventional computer uses ordinal numbers to represent data samples(e.g. images or audio signals), different data samples are representedby different numeric values. The different numeric values do not provideany information about how similar or dissimilar one data sample is fromanother. In other words, conventional computers are only able to makebinary comparisons of data samples which only results in determiningwhether the data samples match or do not match. Unless there is an exactmatch in ordinal number values, conventional systems are unable to tellif a data sample matches or is similar to any other data samples. As aresult, conventional computers are unable to use ordinal numbers bythemselves for determining similarity between different data samples,and instead these computers rely on complex signal processingtechniques. Determining whether a data sample matches or is similar toother data samples is not a trivial task and poses several technicalchallenges for conventional computers. These technical challenges resultin complex processes that consume processing power which reduces thespeed and performance of the system.

In contrast to conventional systems, the user device 100 operates as aspecial purpose machine for implementing or emulating a correlithmobject processing system. Implementing or emulating a correlithm objectprocessing system improves the operation of the user device 100 byenabling the user device 100 to perform non-binary comparisons (i.e.match or no match) between different data samples. This enables the userdevice 100 to quantify a degree of similarity between different datasamples. This increases the flexibility of the user device 100 to workwith data samples having different data types and/or formats, and alsoincreases the speed and performance of the user device 100 whenperforming operations using data samples. These improvements and otherbenefits to the user device 100 are described in more detail below andthroughout the disclosure.

For example, the user device 100 employs the correlithm objectprocessing system to allow the user device 100 to compare data sampleseven when the input data sample does not exactly match any known orpreviously stored input values. Implementing a correlithm objectprocessing system fundamentally changes the user device 100 and thetraditional data processing paradigm. Implementing the correlithm objectprocessing system improves the operation of the user device 100 byenabling the user device 100 to perform non-binary comparisons of datasamples. In other words, the user device 100 is able to determine howsimilar the data samples are to each other even when the data samplesare not exact matches. In addition, the user device 100 is able toquantify how similar data samples are to one another. The ability todetermine how similar data samples are to each others is unique anddistinct from conventional computers that can only perform binarycomparisons to identify exact matches.

The user device's 100 ability to perform non-binary comparisons of datasamples also fundamentally changes traditional data searching paradigms.For example, conventional search engines rely on finding exact matchesor exact partial matches of search tokens to identify related datasamples. For instance, conventional text-based search engine are limitedto finding related data samples that have text that exactly matchesother data samples. These search engines only provide a binary resultthat identifies whether or not an exact match was found based on thesearch token. Implementing the correlithm object processing systemimproves the operation of the user device 100 by enabling the userdevice 100 to identify related data samples based on how similar thesearch token is to other data sample. These improvements result inincreased flexibility and faster search time when using a correlithmobject processing system. The ability to identify similarities betweendata samples expands the capabilities of a search engine to include datasamples that may not have an exact match with a search token but arestill related and similar in some aspects. The user device 100 is alsoable to quantify how similar data samples are to each other based oncharacteristics besides exact matches to the search token. Implementingthe correlithm object processing system involves operating the userdevice 100 in an unconventional manner to achieve these technologicalimprovements as well as other benefits described below for the userdevice 100.

Computing devices typically rely on the ability to compare data sets(e.g. data samples) to one another for processing. For example, insecurity or authentication applications a computing device is configuredto compare an input of an unknown person to a data set of known people(or biometric information associated with these people). The problemsassociated with comparing data sets and identifying matches based on thecomparison are problems necessarily rooted in computer technologies. Asdescribed above, conventional systems are limited to a binary comparisonthat can only determine whether an exact match is found. As an example,an input data sample that is an image of a person may have differentlighting conditions than previously stored images. In this example,different lighting conditions can make images of the same person appeardifferent from each other. Conventional computers are unable todistinguish between two images of the same person with differentlighting conditions and two images of two different people withoutcomplicated signal processing. In both of these cases, conventionalcomputers can only determine that the images are different. This isbecause conventional computers rely on manipulating ordinal numbers forprocessing.

In contrast, the user device 100 uses an unconventional configurationthat uses correlithm objects to represent data samples. Using correlithmobjects to represent data samples fundamentally changes the operation ofthe user device 100 and how the device views data samples. Byimplementing a correlithm object processing system, the user device 100can determine the distance between the data samples and other known datasamples to determine whether the input data sample matches or is similarto the other known data samples, as explained in detail below. Unlikethe conventional computers described in the previous example, the userdevice 100 is able to distinguish between two images of the same personwith different lighting conditions and two images of two differentpeople by using correlithm objects 104. Correlithm objects allow theuser device 100 to determine whether there are any similarities betweendata samples, such as between two images that are different from eachother in some respects but similar in other respects. For example, theuser device 100 is able to determine that despite different lightingconditions, the same person is present in both images.

In addition, the user device 100 is able to determine a degree ofsimilarity that quantifies how similar different data samples are to oneanother. Implementing a correlithm object processing system in the userdevice 100 improves the operation of the user device 100 when comparingdata sets and identifying matches by allowing the user device 100 toperform non-binary comparisons between data sets and to quantify thesimilarity between different data samples. In addition, using acorrelithm object processing system results in increased flexibility andfaster search times when comparing data samples or data sets. Thus,implementing a correlithm object processing system in the user device100 provides a technical solution to a problem necessarily rooted incomputer technologies.

The ability to implement a correlithm object processing system providesa technical advantage by allowing the system to identify and comparedata samples regardless of whether an exact match has been previousobserved or stored. In other words, using the correlithm objectprocessing system the user device 100 is able to identify similar datasamples to an input data sample in the absence of an exact match. Thisfunctionality is unique and distinct from conventional computers thatcan only identify data samples with exact matches.

Examples of data samples include, but are not limited to, images, files,text, audio signals, biometric signals, electric signals, or any othersuitable type of data. A correlithm object 104 is a point in then-dimensional space 102, sometimes called an “n-space.” The value ofrepresents the number of dimensions of the space. For example, ann-dimensional space 102 may be a 3-dimensional space, a 50-dimensionalspace, a 100-dimensional space, or any other suitable dimension space.The number of dimensions depends on its ability to support certainstatistical tests, such as the distances between pairs of randomlychosen points in the space approximating a normal distribution. In someembodiments, increasing the number of dimensions in the n-dimensionalspace 102 modifies the statistical properties of the system to provideimproved results. Increasing the number of dimensions increases theprobability that a correlithm object 104 is similar to other adjacentcorrelithm objects 104. In other words, increasing the number ofdimensions increases the correlation between how close a pair ofcorrelithm objects 104 are to each other and how similar the correlithmobjects 104 are to each other.

Correlithm object processing systems use new types of data structurescalled correlithm objects 104 that improve the way a device operates,for example, by enabling the device to perform non-binary data setcomparisons and to quantify the similarity between different datasamples. Correlithm objects 104 are data structures designed to improvethe way a device stores, retrieves, and compares data samples in memory.Unlike conventional data structures, correlithm objects 104 are datastructures where objects can be expressed in a high-dimensional spacesuch that distance 106 between points in the space represent thesimilarity between different objects or data samples. In other words,the distance 106 between a pair of correlithm objects 104 in then-dimensional space 102 indicates how similar the correlithm objects 104are from each other and the data samples they represent. Correlithmobjects 104 that are close to each other are more similar to each otherthan correlithm objects 104 that are further apart from each other. Forexample, in a facial recognition application, correlithm objects 104used to represent images of different types of glasses may be relativelyclose to each other compared to correlithm objects 104 used to representimages of other features such as facial hair. An exact match between twodata samples occurs when their corresponding correlithm objects 104 arethe same or have no distance between them. When two data samples are notexact matches but are similar, the distance between their correlithmobjects 104 can be used to indicate their similarities. In other words,the distance 106 between correlithm objects 104 can be used to identifyboth data samples that exactly match each other as well as data samplesthat do not match but are similar. This feature is unique to acorrelithm processing system and is unlike conventional computers thatare unable to detect when data samples are different but similar in someaspects.

Correlithm objects 104 also provide a data structure that is independentof the data type and format of the data samples they represent.Correlithm objects 104 allow data samples to be directly comparedregardless of their original data type and/or format. In some instances,comparing data samples as correlithm objects 104 is computationally moreefficient and faster than comparing data samples in their originalformat. For example, comparing images using conventional data structuresinvolves significant amounts of image processing which is time consumingand consumes processing resources. Thus, using correlithm objects 104 torepresent data samples provides increased flexibility and improvedperformance compared to using other conventional data structures.

In one embodiment, correlithm objects 104 may be represented usingcategorical binary strings. The number of bits used to represent thecorrelithm object 104 corresponds with the number of dimensions of then-dimensional space 102 where the correlithm object 102 is located. Forexample, each correlithm object 104 may be uniquely identified using a64-bit string in a 64-dimensional space 102. As another example, eachcorrelithm object 104 may be uniquely identified using a 10-bit stringin a 10-dimensional space 102. In other examples, correlithm objects 104can be identified using any other suitable number of bits in a stringthat corresponds with the number of dimensions in the n-dimensionalspace 102.

In this configuration, the distance 106 between two correlithm objects104 can be determined based on the differences between the bits of thetwo correlithm objects 104. In other words, the distance 106 between twocorrelithm objects can be determined based on how many individual bitsdiffer between the correlithm objects 104. The distance 106 between twocorrelithm objects 104 can be computed using hamming distance or anyother suitable technique.

As an example using a 10-dimensional space 102, a first correlithmobject 104 is represented by a first 10-bit string (1001011011) and asecond correlithm object 104 is represented by a second 10-bit string(1000011011). The hamming distance corresponds with the number of bitsthat differ between the first correlithm object 104 and the secondcorrelithm object 104. In other words, the hamming distance between thefirst correlithm object 104 and the second correlithm object 104 can becomputed as follows:

$\frac{\begin{matrix}1001011011 \\1000011011\end{matrix}}{0001000000}$In this example, the hamming distance is equal to one because only onebit differs between the first correlithm object 104 and the secondcorrelithm object. As another example, a third correlithm object 104 isrepresented by a third 10-bit string (0110100100). In this example, thehamming distance between the first correlithm object 104 and the thirdcorrelithm object 104 can be computed as follows:

$\frac{\begin{matrix}1001011011 \\0110100100\end{matrix}}{1111111111}$The hamming distance is equal to ten because all of the bits aredifferent between the first correlithm object 104 and the thirdcorrelithm object 104. In the previous example, a hamming distance equalto one indicates that the first correlithm object 104 and the secondcorrelithm object 104 are close to each other in the n-dimensional space102, which means they are similar to each other. In the second example,a hamming distance equal to ten indicates that the first correlithmobject 104 and the third correlithm object 104 are further from eachother in the n-dimensional space 102 and are less similar to each otherthan the first correlithm object 104 and the second correlithm object104. In other words, the similarity between a pair of correlithm objectscan be readily determined based on the distance between the paircorrelithm objects.

As another example, the distance between a pair of correlithm objects104 can be determined by performing an XOR operation between the pair ofcorrelithm objects 104 and counting the number of logical high values inthe binary string. The number of logical high values indicates thenumber of bits that are different between the pair of correlithm objects104 which also corresponds with the hamming distance between the pair ofcorrelithm objects 104.

In another embodiment, the distance 106 between two correlithm objects104 can be determined using a Minkowski distance such as the Euclideanor “straight-line” distance between the correlithm objects 104. Forexample, the distance 106 between a pair of correlithm objects 104 maybe determined by calculating the square root of the sum of squares ofthe coordinate difference in each dimension.

The user device 100 is configured to implement or emulate a correlithmobject processing system that comprises one or more sensors 302, nodes304, and/or actors 306 in order to convert data samples between realworld values or representations and to correlithm objects 104 in acorrelithm object domain. Sensors 302 are generally configured toconvert real world data samples to the correlithm object domain. Nodes304 are generally configured to process or perform various operations oncorrelithm objects in the correlithm object domain. Actors 306 aregenerally configured to convert correlithm objects 104 into real worldvalues or representations. Additional information about sensors 302,nodes 304, and actors 306 is described in FIG. 3.

Performing operations using correlithm objects 104 in a correlithmobject domain allows the user device 100 to identify relationshipsbetween data samples that cannot be identified using conventional dataprocessing systems. For example, in the correlithm object domain, theuser device 100 is able to identify not only data samples that exactlymatch an input data sample, but also other data samples that havesimilar characteristics or features as the input data samples.Conventional computers are unable to identify these types ofrelationships readily. Using correlithm objects 104 improves theoperation of the user device 100 by enabling the user device 100 toefficiently process data samples and identify relationships between datasamples without relying on signal processing techniques that require asignificant amount of processing resources. These benefits allow theuser device 100 to operate more efficiently than conventional computersby reducing the amount of processing power and resources that are neededto perform various operations.

FIG. 2 is a schematic view of an embodiment of a mapping betweencorrelithm objects 104 in different n-dimensional spaces 102. Whenimplementing a correlithm object processing system, the user device 100performs operations within the correlithm object domain using correlithmobjects 104 in different n-dimensional spaces 102. As an example, theuser device 100 may convert different types of data samples having realworld values into correlithm objects 104 in different n-dimensionalspaces 102. For instance, the user device 100 may convert data samplesof text into a first set of correlithm objects 104 in a firstn-dimensional space 102 and data samples of audio samples as a secondset of correlithm objects 104 in a second n-dimensional space 102.Conventional systems require data samples to be of the same type and/orformat in order to perform any kind of operation on the data samples. Insome instances, some types of data samples cannot be compared becausethere is no common format available. For example, conventional computersare unable to compare data samples of images and data samples of audiosamples because there is no common format. In contrast, the user device100 implementing a correlithm object processing system is able tocompare and perform operations using correlithm objects 104 in thecorrelithm object domain regardless of the type or format of theoriginal data samples.

In FIG. 2, a first set of correlithm objects 104A are defined within afirst n-dimensional space 102A and a second set of correlithm objects104B are defined within a second n-dimensional space 102B. Then-dimensional spaces may have the same number dimensions or a differentnumber of dimensions. For example, the first n-dimensional space 102Aand the second n-dimensional space 102B may both be three dimensionalspaces. As another example, the first n-dimensional space 102A may be athree dimensional space and the second n-dimensional space 102B may be anine dimensional space. Correlithm objects 104 in the firstn-dimensional space 102A and second n-dimensional space 102B are mappedto each other. In other words, a correlithm object 104A in the firstn-dimensional space 102A may reference or be linked with a particularcorrelithm object 104B in the second n-dimensional space 102B. Thecorrelithm objects 104 may also be linked with and referenced with othercorrelithm objects 104 in other n-dimensional spaces 102.

In one embodiment, a data structure such as table 200 may be used to mapor link correlithm objects 194 in different n-dimensional spaces 102. Insome instances, table 200 is referred to as a node table. Table 200 isgenerally configured to identify a first plurality of correlithm objects104 in a first n-dimensional space 102 and a second plurality ofcorrelithm objects 104 in a second n-dimensional space 102. Eachcorrelithm object 104 in the first n-dimensional space 102 is linkedwith a correlithm object 104 is the second n-dimensional space 102. Forexample, table 200 may be configured with a first column 202 that listscorrelithm objects 104A as source correlithm objects and a second column204 that lists corresponding correlithm objects 104B as targetcorrelithm objects. In other examples, table 200 may be configured inany other suitable manner or may be implemented using any other suitabledata structure. In some embodiments, one or more mapping functions maybe used to convert between a correlithm object 104 in a firstn-dimensional space and a correlithm object 104 is a secondn-dimensional space.

FIG. 3 is a schematic view of an embodiment of a correlithm objectprocessing system 300 that is implemented by a user device 100 toperform operations using correlithm objects 104. The system 300generally comprises a sensor 302, a node 304, and an actor 306. Thesystem 300 may be configured with any suitable number and/orconfiguration of sensors 302, nodes 304, and actors 306. An example ofthe system 300 in operation is described in FIG. 4. In one embodiment, asensor 302, a node 304, and an actor 306 may all be implemented on thesame device (e.g. user device 100). In other embodiments, a sensor 302,a node 304, and an actor 306 may each be implemented on differentdevices in signal communication with each other for example over anetwork. In other embodiments, different devices may be configured toimplement any combination of sensors 302, nodes 304, and actors 306.

Sensors 302 serve as interfaces that allow a user device 100 to convertreal world data samples into correlithm objects 104 that can be used inthe correlithm object domain. Sensors 302 enable the user device 100compare and perform operations using correlithm objects 104 regardlessof the data type or format of the original data sample. Sensors 302 areconfigured to receive a real world value 320 representing a data sampleas an input, to determine a correlithm object 104 based on the realworld value 320, and to output the correlithm object 104. For example,the sensor 302 may receive an image 301 of a person and output acorrelithm object 322 to the node 304 or actor 306. In one embodiment,sensors 302 are configured to use sensor tables 308 that link aplurality of real world values with a plurality of correlithm objects104 in an n-dimensional space 102. Real world values are any type ofsignal, value, or representation of data samples. Examples of real worldvalues include, but are not limited to, images, pixel values, text,audio signals, electrical signals, and biometric signals. As an example,a sensor table 308 may be configured with a first column 312 that listsreal world value entries corresponding with different images and asecond column 314 that lists corresponding correlithm objects 104 asinput correlithm objects. In other examples, sensor tables 308 may beconfigured in any other suitable manner or may be implemented using anyother suitable data structure. In some embodiments, one or more mappingfunctions may be used to translate between a real world value 320 and acorrelithm object 104 is a n-dimensional space 102. Additionalinformation for implementing or emulating a sensor 302 in hardware isdescribed in FIG. 5.

Nodes 304 are configured to receive a correlithm object 104 (e.g. aninput correlithm object 104), to determine another correlithm object 104based on the received correlithm object 104, and to output theidentified correlithm object 104 (e.g. an output correlithm object 104).In one embodiment, nodes 304 are configured to use node tables 200 thatlink a plurality of correlithm objects 104 from a first n-dimensionalspace 102 with a plurality of correlithm objects 104 in a secondn-dimensional space 102. A node table 200 may be configured similar tothe table 200 described in FIG. 2. Additional information forimplementing or emulating a node 304 in hardware is described in FIG. 5.

Actors 306 serve as interfaces that allow a user device 100 to convertcorrelithm objects 104 in the correlithm object domain back to realworld values or data samples. Actors 306 enable the user device 100 toconvert from correlithm objects 104 into any suitable type of real worldvalue. Actors 306 are configured to receive a correlithm object 104(e.g. an output correlithm object 104), to determine a real world outputvalue 326 based on the received correlithm object 104, and to output thereal world output value 326. The real world output value 326 may be adifferent data type or representation of the original data sample. As anexample, the real world input value 320 may be an image 301 of a personand the resulting real world output value 326 may be text 327 and/or anaudio signal identifying the person. In one embodiment, actors 306 areconfigured to use actor tables 310 that link a plurality of correlithmobjects 104 in an n-dimensional space 102 with a plurality of real worldvalues. As an example, an actor table 310 may be configured with a firstcolumn 316 that lists correlithm objects 104 as output correlithmobjects and a second column 318 that lists real world values. In otherexamples, actor tables 310 may be configured in any other suitablemanner or may be implemented using any other suitable data structure. Insome embodiments, one or more mapping functions may be employed totranslate between a correlithm object 104 in an n-dimensional space anda real world output value 326. Additional information for implementingor emulating an actor 306 in hardware is described in FIG. 5.

A correlithm object processing system 300 uses a combination of a sensortable 308, a node table 200, and/or an actor table 310 to provide aspecific set of rules that improve computer-related technologies byenabling devices to compare and to determine the degree of similaritybetween different data samples regardless of the data type and/or formatof the data sample they represent. The ability to directly compare datasamples having different data types and/or formatting is a newfunctionality that cannot be performed using conventional computingsystems and data structures. Conventional systems require data samplesto be of the same type and/or format in order to perform any kind ofoperation on the data samples. In some instances, some types of datasamples are incompatible with each other and cannot be compared becausethere is no common format available. For example, conventional computersare unable to compare data samples of images with data samples of audiosamples because there is no common format available. In contrast, adevice implementing a correlithm object processing system uses acombination of a sensor table 308, a node table 200, and/or an actortable 310 to compare and perform operations using correlithm objects 104in the correlithm object domain regardless of the type or format of theoriginal data samples. The correlithm object processing system 300 usesa combination of a sensor table 308, a node table 200, and/or an actortable 310 as a specific set of rules that provides a particular solutionto dealing with different types of data samples and allows devices toperform operations on different types of data samples using correlithmobjects 104 in the correlithm object domain. In some instances,comparing data samples as correlithm objects 104 is computationally moreefficient and faster than comparing data samples in their originalformat. Thus, using correlithm objects 104 to represent data samplesprovides increased flexibility and improved performance compared tousing other conventional data structures. The specific set of rules usedby the correlithm object processing system 300 go beyond simply usingroutine and conventional activities in order to achieve this newfunctionality and performance improvements.

In addition, correlithm object processing system 300 uses a combinationof a sensor table 308, a node table 200, and/or an actor table 310 toprovide a particular manner for transforming data samples betweenordinal number representations and correlithm objects 104 in acorrelithm object domain. For example, the correlithm object processingsystem 300 may be configured to transform a representation of a datasample into a correlithm object 104, to perform various operations usingthe correlithm object 104 in the correlithm object domain, and totransform a resulting correlithm object 104 into another representationof a data sample. Transforming data samples between ordinal numberrepresentations and correlithm objects 104 involves fundamentallychanging the data type of data samples between an ordinal number systemand a categorical number system to achieve the previously describedbenefits of the correlithm object processing system 300.

FIG. 4 is a protocol diagram of an embodiment of a correlithm objectprocess flow 400. A user device 100 implements process flow 400 toemulate a correlithm object processing system 300 to perform operationsusing correlithm object 104 such as facial recognition. The user device100 implements process flow 400 to compare different data samples (e.g.images, voice signals, or text) are to each other and to identify otherobjects based on the comparison. Process flow 400 provides instructionsthat allows user devices 100 to achieve the improved technical benefitsof a correlithm object processing system 300.

Conventional systems are configured to use ordinal numbers foridentifying different data samples. Ordinal based number systems onlyprovide information about the sequence order of numbers based on theirnumeric values, and do not provide any information about any other typesof relationships for the data samples being represented by the numericvalues such as similarity. In contrast, a user device 100 can implementor emulate the correlithm object processing system 300 which provides anunconventional solution that uses categorical numbers and correlithmobjects 104 to represent data samples. For example, the system 300 maybe configured to use binary integers as categorical numbers to generatecorrelithm objects 104 which enables the user device 100 to performoperations directly based on similarities between different datasamples. Categorical numbers provide information about how similardifferent data sample are from each other. Correlithm objects 104generated using categorical numbers can be used directly by the system300 for determining how similar different data samples are from eachother without relying on exact matches, having a common data type orformat, or conventional signal processing techniques.

A non-limiting example is provided to illustrate how the user device 100implements process flow 400 to emulate a correlithm object processingsystem 300 to perform facial recognition on an image to determine theidentity of the person in the image. In other examples, the user device100 may implement process flow 400 to emulate a correlithm objectprocessing system 300 to perform voice recognition, text recognition, orany other operation that compares different objects.

At step 402, a sensor 302 receives an input signal representing a datasample. For example, the sensor 302 receives an image of person's faceas a real world input value 320. The input signal may be in any suitabledata type or format. In one embodiment, the sensor 302 may obtain theinput signal in real-time from a peripheral device (e.g. a camera). Inanother embodiment, the sensor 302 may obtain the input signal from amemory or database.

At step 404, the sensor 302 identifies a real world value entry in asensor table 308 based on the input signal. In one embodiment, thesystem 300 identifies a real world value entry in the sensor table 308that matches the input signal. For example, the real world value entriesmay comprise previously stored images. The sensor 302 may compare thereceived image to the previously stored images to identify a real worldvalue entry that matches the received image. In one embodiment, when thesensor 302 does not find an exact match, the sensor 302 finds a realworld value entry that closest matches the received image.

At step 406, the sensor 302 identifies and fetches an input correlithmobject 104 in the sensor table 308 linked with the real world valueentry. At step 408, the sensor 302 sends the identified input correlithmobject 104 to the node 304. In one embodiment, the identified inputcorrelithm object 104 is represented in the sensor table 308 using acategorical binary integer string. The sensor 302 sends the binarystring representing to the identified input correlithm object 104 to thenode 304.

At step 410, the node 304 receives the input correlithm object 104 anddetermines distances 106 between the input correlithm object 104 andeach source correlithm object 104 in a node table 200. In oneembodiment, the distance 106 between two correlithm objects 104 can bedetermined based on the differences between the bits of the twocorrelithm objects 104. In other words, the distance 106 between twocorrelithm objects can be determined based on how many individual bitsdiffer between a pair of correlithm objects 104. The distance 106between two correlithm objects 104 can be computed using hammingdistance or any other suitable technique. In another embodiment, thedistance 106 between two correlithm objects 104 can be determined usinga Minkowski distance such as the Euclidean or “straight-line” distancebetween the correlithm objects 104. For example, the distance 106between a pair of correlithm objects 104 may be determined bycalculating the square root of the sum of squares of the coordinatedifference in each dimension.

At step 412, the node 304 identifies a source correlithm object 104 fromthe node table 200 with the shortest distance 106. A source correlithmobject 104 with the shortest distance from the input correlithm object104 is a correlithm object 104 either matches or most closely matchesthe received input correlithm object 104.

At step 414, the node 304 identifies and fetches a target correlithmobject 104 in the node table 200 linked with the source correlithmobject 104. At step 416, the node 304 outputs the identified targetcorrelithm object 104 to the actor 306. In this example, the identifiedtarget correlithm object 104 is represented in the node table 200 usinga categorical binary integer string. The node 304 sends the binarystring representing to the identified target correlithm object 104 tothe actor 306.

At step 418, the actor 306 receives the target correlithm object 104 anddetermines distances between the target correlithm object 104 and eachoutput correlithm object 104 in an actor table 310. The actor 306 maycompute the distances between the target correlithm object 104 and eachoutput correlithm object 104 in an actor table 310 using a processsimilar to the process described in step 410.

At step 420, the actor 306 identifies an output correlithm object 104from the actor table 310 with the shortest distance 106. An outputcorrelithm object 104 with the shortest distance from the targetcorrelithm object 104 is a correlithm object 104 either matches or mostclosely matches the received target correlithm object 104.

At step 422, the actor 306 identifies and fetches a real world outputvalue in the actor table 310 linked with the output correlithm object104. The real world output value may be any suitable type of data samplethat corresponds with the original input signal. For example, the realworld output value may be text that indicates the name of the person inthe image or some other identifier associated with the person in theimage. As another example, the real world output value may be an audiosignal or sample of the name of the person in the image. In otherexamples, the real world output value may be any other suitable realworld signal or value that corresponds with the original input signal.The real world output value may be in any suitable data type or format.

At step 424, the actor 306 outputs the identified real world outputvalue. In one embodiment, the actor 306 may output the real world outputvalue in real-time to a peripheral device (e.g. a display or a speaker).In one embodiment, the actor 306 may output the real world output valueto a memory or database. In one embodiment, the real world output valueis sent to another sensor 302. For example, the real world output valuemay be sent to another sensor 302 as an input for another process.

FIG. 5 is a schematic diagram of an embodiment a computer architecture500 for emulating a correlithm object processing system 300 in a userdevice 100. The computer architecture 500 comprises a processor 502, amemory 504, a network interface 506, and an input-output (I/O) interface508. The computer architecture 500 may be configured as shown or in anyother suitable configuration.

The processor 502 comprises one or more processors operably coupled tothe memory 504. The processor 502 is any electronic circuitry including,but not limited to, state machines, one or more central processing unit(CPU) chips, logic units, cores (e.g. a multi-core processor),field-programmable gate array (FPGAs), application specific integratedcircuits (ASICs), graphics processing units (GPUs), or digital signalprocessors (DSPs). The processor 502 may be a programmable logic device,a microcontroller, a microprocessor, or any suitable combination of thepreceding. The processor 502 is communicatively coupled to and in signalcommunication with the memory 204. The one or more processors areconfigured to process data and may be implemented in hardware orsoftware. For example, the processor 502 may be 8-bit, 16-bit, 32-bit,64-bit or of any other suitable architecture. The processor 502 mayinclude an arithmetic logic unit (ALU) for performing arithmetic andlogic operations, processor registers that supply operands to the ALUand store the results of ALU operations, and a control unit that fetchesinstructions from memory and executes them by directing the coordinatedoperations of the ALU, registers and other components.

The one or more processors are configured to implement variousinstructions. For example, the one or more processors are configured toexecute instructions to implement sensor engines 510, node engines 512,and actor engines 514. In an embodiment, the sensor engines 510, thenode engines 512, and the actor engines 514 are implemented using logicunits, FPGAs, ASICs, DSPs, or any other suitable hardware. The sensorengines 510, the node engines 512, and the actor engines 514 are eachconfigured to implement a specific set of rules or process that providesan improved technological result.

In one embodiment, the sensor engine 510 is configured to receive a realworld value 320 as an input, to determine a correlithm object 104 basedon the real world value 320, and to output the correlithm object 104.Examples of the sensor engine 510 in operation are described in FIGS. 4and 11.

In one embodiment, the node engine 512 is configured to receive acorrelithm object 104 (e.g. an input correlithm object 104), todetermine another correlithm object 104 based on the received correlithmobject 104, and to output the identified correlithm object 104 (e.g. anoutput correlithm object 104). The node engine 512 is also configured tocompute distances between pairs of correlithm objects 104. Examples ofthe node engine 512 in operation are described in FIGS. 4, 6-12, 14,15A, 15B, and 18.

In one embodiment, the actor engine 514 is configured to receive acorrelithm object 104 (e.g. an output correlithm object 104), todetermine a real world output value 326 based on the received correlithmobject 104, and to output the real world output value 326. Examples ofthe actor engine 514 in operation are described in FIGS. 4 and 11.

The memory 504 comprises one or more non-transitory disks, tape drives,or solid-state drives, and may be used as an over-flow data storagedevice, to store programs when such programs are selected for execution,and to store instructions and data that are read during programexecution. The memory 504 may be volatile or non-volatile and maycomprise read-only memory (ROM), random-access memory (RAM), ternarycontent-addressable memory (TCAM), dynamic random-access memory (DRAM),and static random-access memory (SRAM). The memory 504 is operable tostore sensor instructions 516, node instructions 518, actor instructions520, sensor tables 308, node tables 200, actor tables 310, and/or anyother data or instructions. The sensor instructions 516, the nodeinstructions 518, and the actor instructions 520 comprise any suitableset of instructions, logic, rules, or code operable to execute thesensor engine 510, node engine 512, and the actor engine 514,respectively.

The sensor tables 308, the node tables 200, and the actor tables 310 maybe configured similar to the sensor tables 308, the node tables 200, andthe actor tables 310 described in FIG. 3, respectively.

The network interface 506 is configured to enable wired and/or wirelesscommunications. The network interface 506 is configured to communicatedata with any other device or system. For example, the network interface506 may be configured for communication with a modem, a switch, arouter, a bridge, a server, or a client. The processor 502 is configuredto send and receive data using the network interface 506.

The I/O interface 508 may comprise ports, transmitters, receivers,transceivers, or any other devices for transmitting and/or receivingdata with peripheral devices as would be appreciated by one of ordinaryskill in the art upon viewing this disclosure. For example, the I/Ointerface 508 may be configured to communicate data between theprocessor 502 and peripheral hardware such as a graphical userinterface, a display, a mouse, a keyboard, a key pad, and a touch sensor(e.g. a touch screen).

FIGS. 6-10 generally describe how a string correlithm object may beimplemented in a correlithm object processing system 300 using a device100. FIG. 6 describes how a string correlithm object embeds differentorders of correlithm objects 104 with each other. FIGS. 7 and 8 combineto describe an embodiment for emulating a string correlithm object in acorrelithm object processing system 300 with a device 100. FIGS. 9 and10 combine to describe another embodiment for emulating a stringcorrelithm object in a correlithm object processing system 300 with adevice 100.

FIGS. 6 and 7 are schematic diagrams of an embodiment of a device 100implementing string correlithm objects 602 for a correlithm objectprocessing system 300. String correlithm objects 602 can be used by acorrelithm object processing system 300 to embed higher orders ofcorrelithm objects 104 within lower orders of correlithm objects 104.The order of a correlithm object 104 depends on the number of bits usedto represent the correlithm object 104. The order of a correlithm object104 also corresponds with the number of dimensions in the n-dimensionalspace 102 where the correlithm object 104 is located. For example, acorrelithm object 104 represented by a 64-bit string is a higher ordercorrelithm object 104 than a correlithm object 104 represented by 16-bitstring.

Conventional computing systems rely on accurate data input and areunable to detect or correct for data input errors in real time. Forexample, a conventional computing device assumes a data stream iscorrect even when the data stream has bit errors. When a bit erroroccurs that leads to an unknown data value, the conventional computingdevice is unable to resolve the error without manual intervention. Incontrast, string correlithm objects 602 enable a device 100 to performoperations such as error correction and interpolation within thecorrelithm object processing system 300. For example, higher ordercorrelithm objects 104 can be used to associate an input correlithmobject 104 with a lower order correlithm 104 when an input correlithmobject does not correspond with a particular correlithm object 104 in ann-dimensional space 102. The correlithm object processing system 300uses the embedded higher order correlithm objects 104 to definecorrelithm objects 104 between the lower order correlithm objects 104which allows the device 100 to identify a correlithm object 104 in thelower order correlithm objects n-dimensional space 102 that correspondswith the input correlithm object 104. Using string correlithm objects602, the correlithm object processing system 300 is able to interpolateand/or to compensate for errors (e.g. bit errors) which improve thefunctionality of the correlithm object processing system 300 and theoperation of the device 100.

In some instances, string correlithm objects 602 may be used torepresent a series of data samples or temporal data samples. Forexample, a string correlithm object 602 may be used to represent audioor video segments. In this example, media segments are represented bysequential correlithm objects that are linked together using a stringcorrelithm object 602.

FIG. 6 illustrates an embodiment of how a string correlithm object 602may be implemented within a node 304 by a device 100. In otherembodiments, string correlithm objects 602 may be integrated within asensor 302 or an actor 306. In 32-dimensional space 102 where correlithmobjects 104 can be represented by a 32-bit string, the 32-bit string canbe embedded and used to represent correlithm objects 104 in a lowerorder 3-dimensional space 102 which uses three bits. The 32-bit stringscan be partitioned into three 12 bit portions, where each portioncorresponds with one of the three bits in the 3-dimensional space 102.For example, the correlithm object 104 represented by the 3 bit binaryvalue of 000 may be represented by a 32-bit binary string of zeros andthe correlithm object represented by the binary value of 111 may berepresented by a 32-bit string of all ones. As another example, thecorrelithm object 104 represented by the 3 bit binary value of 100 maybe represented by a 32-bit binary string with 12 bits set to onefollowed by 24 bits set to zero. In other examples, string correlithmobjects 602 can be used to embed any other combination and/or number ofn-dimensional spaces 102.

In one embodiment, when a higher order n-dimensional space 102 isembedded in a lower order n-dimensional space 102, one or morecorrelithm objects 104 are present in both the lower order n-dimensionalspace 102 and the higher order n-dimensional space 102. Correlithmobjects 104 that are present in both the lower order n-dimensional space102 and the higher order n-dimensional space 102 may be referred to asparent correlithm objects 603. Correlithm objects 104 in the higherorder n-dimensional space 102 may be referred to as child correlithmobjects 604. In this example, the correlithm objects 104 in the3-dimensional space 102 may be referred to as parent correlithm objects603 while the correlithm objects 104 in the 32-dimensional space 102 maybe referred to as child correlithm objects 604. In general, childcorrelithm objects 604 are represented by a higher order binary stringthan parent correlithm objects 603. In other words, the bit strings usedto represent a child correlithm object 604 may have more bits than thebit strings used to represent a parent correlithm object 603. Thedistance between parent correlithm objects 603 may be referred to as astandard distance. The distance between child correlithm objects 604 andother child correlithm objects 604 or parent correlithm objects 603 maybe referred to as a fractional distance which is less than the standarddistance.

FIG. 7 illustrates another embodiment of how a string correlithm object602 may be implemented within a node 304 by a device 100. In otherembodiments, string correlithm objects 602 may be integrated within asensor 302 or an actor 306. In FIG. 7, a set of correlithm objects 104are shown within an n-dimensional space 102. In one embodiment, thecorrelithm objects 104 are equally spaced from adjacent correlithmobjects 104. A string correlithm object 602 comprises a parentcorrelithm object 603 linked with one or more child correlithm objects604. FIG. 7 illustrates three string correlithm objects 602 where eachstring correlithm object 602 comprises a parent correlithm object 603linked with six child correlithm objects 603. In other examples, then-dimensional space 102 may comprise any suitable number of correlithmobjects 104 and/or string correlithm objects 602. An example of aprocess for generating a string correlithm object 602 is described inFIG. 8.

A parent correlithm object 603 may be a member of one or more stringcorrelithm objects 602. For example, a parent correlithm object 603 maybe linked with one or more sets child correlithm objects 604 in a nodetable 200. In one embodiment, a child correlithm object 604 may only belinked with one parent correlithm object 603. String correlithm objects602 may be configured to form a daisy chain or a linear chain of childcorrelithm objects 604. In one embodiment, string correlithm objects 602are configured such that child correlithm objects 604 do not form loopswhere the chain of child correlithm objects 604 intersect withthemselves. Each child correlithm objects 604 is less than the standarddistance away from its parent correlithm object 603. The childcorrelithm objects 604 are equally spaced from other adjacent childcorrelithm objects 604.

In one embodiment, a data structure such as node table 200 may be usedto map or link parent correlithm objects 603 with child correlithmobjects 604. The node table 200 is generally configured to identify aplurality of parent correlithm objects 603 and one or more childcorrelithm objects 604 linked with each of the parent correlithm objects603. For example, node table 200 may be configured with a first columnthat lists child correlithm objects 604 and a second column that listsparent correlithm objects 603. In other examples, the node table 200 maybe configured in any other suitable manner or may be implemented usingany other suitable data structure. In some embodiments, one or moremapping functions may be used to convert between a child correlithmobject 604 and a parent correlithm object 603.

FIG. 8 is a flowchart of an embodiment of a process 800 for emulating orgenerating string correlithm objects 602 for a correlithm objectprocessing system 300. Process flow 800 provides instructions thatallows the user device 100 to emulate or generate string correlithmobject 602 in a node 304 which can be used by the correlithm objectprocessing system 300 for applications that involve functions like errorcorrection, interpolation, data compression, and quantization. In otherembodiments, process 800 may be implemented by a sensor 302 or an actor306. In some instances, the string correlithm objects 602 generated byprocess 800 may be referred to as drift-away string correlithm objects.

As previously described above, conventional computing systems rely onaccurate data input and are unable to detect or correct for data inputerrors in real time. When a bit error occurs that leads to an unknowndata value, the conventional computing device is unable to resolve theerror without manual intervention. In contrast, string correlithmobjects 602 enable a device 100 to perform operations such as errorcorrection and interpolation within the correlithm object processingsystem 300.

A non-limiting example is provided to illustrate how the user device 100implements process 800 to emulate or generate a string correlithm object602 for a correlithm object processing system 300. Process flow 800 mayapplied or extended to a variety of applications which involve functionssuch as error correction, interpolation, data compression, andquantization.

At step 802, the node 304 defines a number of child correlithm objects604 for a string correlithm object 602. For example, the node 304 maydefine a string correlithm object 602 as having 16 child correlithmobjects 604 linked with a parent correlithm object 603. In otherexamples, the node 304 may define any suitable number of childcorrelithm objects 604 that will be used to form the sting correlithmobject 602.

At step 804, the node 304 selects a correlithm object 104 in then-dimensional space 102. The n-dimensional space 102 may be formed by afirst n-dimensional space 102 that is embedded in a second n-dimensionalspace 102, where the first n-dimensional space 102 has a great number ofdimensions than the second n-dimensional space 102. For example, thenode 304 may randomly select a correlithm object 104. As anotherexample, the node 304 may select a correlithm object 104 based oninformation provided (e.g. an identifier) by a user of the device 100.At step 806, the node 304 sets the selected correlithm object 104 as aparent correlithm object 603. In one embodiment, setting the correlithmobject 104 as the parent correlithm object 603 comprises adding an entryin a node table 200 that identifies the selected correlithm object 104as a parent correlithm object 603.

At step 808, the node 304 steps away from the parent correlithm object603 in a random direction. For example, the node 304 may randomly selecta correlithm object 104 that is less than the standard distance awayfrom the parent correlithm object 603. In one embodiment, the node 304may identify a random correlithm object 104 that is adjacent (e.g. onehop away) to the parent correlithm object 603. In another embodiment,the node 304 may identify a random correlithm object 104 that is morethan one hop away from the parent correlithm object 603. For example,the node 304 may select a correlithm object 104 that is three hops awayfrom the parent correlithm object 603. In other examples, the node 304may select a correlithm object 104 that is any other suitable number ofhops away from the parent correlithm object 603. At step 810, the node304 defines a child correlithm object 604 at the current location of therandomly selected correlithm object 104. In one embodiment, defining thechild correlithm object 604 comprises adding an entry in the node table200 that identifies the child correlithm object 604. At step 812, thenode 304 increments a counter. The node 304 increments the counter tokeep track of how many child correlithm objects 604 have been identifiedand/or added to the node table 200. In one embodiment, the counterfunctionality may be performed internally by the node 304. In otherembodiments, the node 304 may be connected to an external device thatprovides the counter functionality.

At step 814, the node 304 steps away from the current child correlithmobject 604 in a random direction. The node 304 may step away from thecurrent child correlithm object 604 to randomly select another adjacentcorrelithm object 104 using a process similar to process described instep 808. At step 816, the node 304 defines a child correlithm object604 at the current location of the randomly selected correlithm object104. The node 304 may define the child correlithm object 604 using aprocess similar to the process described in step 810. At step 818, thenode 304 increments the counter in response to defining another childcorrelithm object 604 and/or adding another child correlithm object 604to the node table 200.

At step 820, the node 304 determines whether the counter value equalsthe defined number of child correlithm objects 604. In other words, thenode 304 uses the current counter value to determine whether the node304 has identified the previously defined number of child correlithmobjects 604 to form a string correlithm object 602. The node 304 returnsto step 814 in response to determining that the counter value does notequal the defined number of child correlithm objects 604. In otherwords, the node 304 returns to step 814 to continue identifyingadditional child correlithm objects 604 until the defined number ofchild correlithm objects 604 has been achieved. The node 304 proceeds tostep 822 in response to determining that the counter value equals thedefined number of child correlithm objects 604. When the counter valueequals the defined number of child correlithm objects 604, the node 304has identified all of the child correlithm objects 604 that will be usedto form the string correlithm object 602.

At step 822, the node 304 links the defined child correlithm object 604with the parent correlithm object 603 to form the string correlithmobject 602. In one embodiment, linking the defined child correlithmobjects 604 with the parent correlithm object 603 comprises linking theidentified child correlithm objects 604 with the parent correlithmobject 603 in the node table 200. Process 800 may be repeated one ormore times to generate additional string correlithm objects 602.

FIG. 9 is a schematic diagram of another embodiment of a device 100implementing string correlithm objects 602 in a node 304 for acorrelithm object processing system 300. Previously in FIG. 7, a stringcorrelithm object 602 comprised of child correlithm objects 604 that areadjacent to a parent correlithm object 603. In FIG. 9, string correlithmobjects 602 comprise one or more child correlithm objects 604 in betweena pair of parent correlithm objects 603. In this configuration, thestring correlithm object 602 initially diverges from a first parentcorrelithm object 603A and then later converges toward a second parentcorrelithm object 603B. This configuration allows the correlithm objectprocessing system 300 to generate a string correlithm object 602 betweena particular pair of parent correlithm objects 603. An example of aprocess for generating a string correlithm object 602 between a pair ofparent correlithm objects 603 is described in FIG. 10.

The string correlithm objects described in FIG. 9 allow the device 100to interpolate value between a specific pair of correlithm objects 104(i.e. parent correlithm objects 603). In other words, these types ofstring correlithm objects 602 allow the device 100 to performinterpolation between a set of parent correlithm objects 603.Interpolation between a set of parent correlithm objects 603 enables thedevice 100 to perform operations such as quantization which convertbetween different orders of correlithm objects 104. An example ofimplementing a quantizer using string correlithm objects 602 isdescribed in FIGS. 11 and 12.

In one embodiment, a data structure such as node table 200 may be usedto map or link the parent correlithm objects 603 with their respectivechild correlithm objects 604. For example, node table 200 may beconfigured with a first column that lists child correlithm objects 604and a second column that lists parent correlithm objects 603. In thisexample, a first portion of the child correlithm objects 604 is linkedwith the first parent correlithm object 603A and a second portion of thechild correlithm objects 604 is linked with the second parent correlithmobject 603B. In other examples, the node table 200 may be configured inany other suitable manner or may be implemented using any other suitabledata structure. In some embodiments, one or more mapping functions maybe used to convert between a child correlithm object 604 and a parentcorrelithm object 603.

FIG. 10 is a flowchart of another embodiment of a process 1000 foremulating string correlithm objects 602 for a correlithm objectprocessing system 300. Process flow 1000 provides instructions thatallows the device 100 to emulate or generate string correlithm objects602 which can be used by the correlithm object processing system 300 forapplications that in involve functions like error correction,interpolation, data compression, and quantization. In other embodiments,process 1000 may be implemented by a sensor 302 or an actor 306. In someinstances, the string correlithm object 602 generated by process 1000may be referred to as drift-between string correlithm objects.

Process 1000 adds to the previously described benefits of using stringcorrelithm objects 602 over conventional computing systems by providingthe ability to generate string correlithm objects 602 between aspecified set of parent correlithm objects 603. This process enables thedevice 100 to perform interpolation between a set of parent correlithmobjects 603. Interpolation between a set of parent correlithm objects603 enables the device 100 to perform operations such as quantization orcompression to convert between different orders of correlithm objects104.

A non-limiting example is provided to illustrate how the device 100implements process flow 1000 to emulate or generate a string correlithmobject 602 for a correlithm object processing system 300. Process 1000may applied or extended to a variety of applications which involvefunctions such as error correction, interpolation, data compression, andquantization.

At step 1002, the node 304 defines a number ‘n’ of child correlithmobjects 604 for a string correlithm object 602. For example, the node304 may define a string correlithm object 602 as having 20 childcorrelithm objects 604 linked with a parent correlithm object 603. Inother examples, the node 304 may define any suitable number of childcorrelithm objects 604 that will be used to form the sting correlithmobject 602. In this example, the number ‘n’ of child correlithm objects604 defines the number of correlithm objects 104 between a pair ofparent correlithm objects 603. The number ‘n’ of child correlithmobjects 604 is divided such that a first portion (e.g. half) of thechild correlithm objects 604 are linked with a first parent correlithmobject 603 and a second portion (e.g. half) of child correlithm objects604 are linked with a second parent correlithm object 603.

At step 1004, the node 304 selects a starting correlithm object 104 inan n-dimensional space 102. The n-dimensional space 102 may be formed bya first n-dimensional space 102 that is embedded in a secondn-dimensional space 102, where the first n-dimensional space 102 has agreat number of dimensions than the second n-dimensional space 102. Forexample, the node 304 may randomly select a correlithm object 104. Asanother example, the node 304 may select a correlithm object 104 basedon information provided (e.g. an identifier) by a user of the device100. At step 1006, the node 304 sets the starting correlithm object 104as a first parent correlithm object 603. In one embodiment, setting thecorrelithm object 104 as the first parent correlithm object 603comprises adding an entry in a node table 200 that identifies theselected correlithm object 104 as the first parent correlithm object603.

At step 1008, the node 304 selects an ending correlithm object 104 inthe n-dimensional space 102. For example, the node 304 may randomlyselect a correlithm object 104. As another example, the node 304 mayselect a correlithm object 104 based on information provided (e.g. anidentifier) by the user of the device 100. At step 1010, the node 304sets the ending correlithm object 104 as a second parent correlithmobject 603. In one embodiment, setting the correlithm object 104 as thesecond parent correlithm object 603 comprises adding an entry in a nodetable 200 that identifies the selected correlithm object 104 as thesecond parent correlithm object 603.

At step 1012, the node 304 steps away from the first parent correlithmobject 603 in a random direction. For example, the node 304 may randomlyselect a correlithm object 104 that is less than the standard distanceaway from the first parent correlithm object 603. In one embodiment, thenode 304 may identify a random correlithm object 104 that is adjacent(e.g. one hop away) to the first parent correlithm object 603. Inanother embodiment, the node 304 may identify a random correlithmobjects that is more than one hop away from the first parent correlithmobject 603. For example, the node 304 may select a correlithm objectthat is two hops away from the first parent correlithm object 603. Inother examples, the node 304 may select a correlithm object 104 that isany other suitable number of hops away from the first parent correlithmobject 603.

At step 1014, the node 304 defines a child correlithm object 604 at thecurrent location of the randomly selected correlithm object 104. In oneembodiment, defining the child correlithm object 604 comprises adding anentry in the node table 200 that identifies the child correlithm object604.

At step 1016, the node 304 increments a counter. The node 304 incrementsthe counter to keep track of how many child correlithm objects 604 havebeen identified and/or added to the node table 200. In one embodiment,the counter functionality may be performed internally by the node 304.In other embodiments, the node 304 may be connected to an externaldevice that provides the counter functionality.

At step 1018, the node 304 steps away from the current child correlithmobject in a random direction. The node 304 may step away from thecurrent child correlithm object 604 to randomly select anothercorrelithm object 104 using a process similar to process described instep 1012. At step 1020, the node 304 defines a child correlithm objectat the current location. The node 304 may define the child correlithmobject 604 using a process similar to the process described in step1014. At step 1022, the node 304 increments the counter in response todefining another child correlithm object 604 and/or adding another childcorrelithm object 604 to the node table 200.

At step 1024, the node 304 determines whether the counter value equalshalf the defined number of child correlithm objects 604. In thisexample, the node 304 links a first portion (e.g. half) of the childcorrelithm objects 604 with the first parent correlithm object 603. Thenode 304 uses the current counter value to determine whether the node304 has identified half of the previously defined number of childcorrelithm objects 604 to form a string correlithm object 602. The node304 returns to step 1018 in response to determining that the countervalue does not equal half the defined number of child correlithm objects604. In other words, the node 304 returns to step 1018 to continueidentifying additional child correlithm objects 604 until half thedefined number of child correlithm objects 604 has been identified. Thenode 304 proceeds to step 1026 in response to determining that thecounter value equals half the defined number of child correlithm objects604.

At step 1026, the node 304 links the first set of defined childcorrelithm objects 604 with the first parent correlithm object 603. Inone embodiment, linking the first set of defined child correlithmobjects 604 with the first parent correlithm object 603 compriseslinking the first set of defined child correlithm objects 604 with thefirst parent correlithm object 603 in the node table 200.

At step 1028, the node 304 steps away from the current child correlithmobject 604 in a random direction towards the second parent correlithmobject 603. The node 304 may step away from the current child correlithmobject 604 to randomly select another correlithm object 104 using aprocess similar to process described in step 1012. At step 1030, thenode 304 defines a child correlithm object at the current location. Thenode 304 may define the child correlithm object 604 using a processsimilar to the process described in step 1014. At step 1032, the node304 increments the counter in response to defining another childcorrelithm object 604 and/or adding another child correlithm object 604to the node table 200.

At step 1034, the node 304 determines whether the counter value equalsthe defined number of child correlithm objects 604. In this example, thenode 304 links a second portion (e.g. half) of the child correlithmobjects 604 with the second parent correlithm object 603. The node 304uses the current counter value to determine whether the node 304 hasidentified the second half of the previously defined number of childcorrelithm objects 604 to form a string correlithm object 602. The node304 returns to step 1028 in response to determining that the countervalue does not equal the defined number of child correlithm objects 604.In other words, the node 304 returns to step 1028 to continueidentifying child correlithm objects 604 until the defined number ofchild correlithm objects 604 has been identified. The node 304 proceedsto step 1036 in response to determining that the counter value equalsthe defined number of child correlithm objects 604.

At step 1036, the node 304 links the second set of defined childcorrelithm objects 604 with the second parent correlithm object 603. Inone embodiment, linking the second set of defined child correlithmobjects 604 with the second parent correlithm object 603 compriseslinking the second set of defined child correlithm objects 604 with thesecond parent correlithm object 603 in the node table 200.

FIGS. 11 and 12 combine to describe an embodiment for emulating aquantizer using string correlithm objects 602 in a correlithm objectprocessing system 300 with a device 100.

FIG. 11 is a schematic diagram of an embodiment of a quantizer 1100 fora correlithm object processing system 300 that is implemented by a userdevice 100. Conventional computing devices typically performs datacompression to reduce the size of data. The data compression process isspecific to the type of data being compressed. For example, downsampling images require a particular process which is different from theprocess used to compress audio samples or music samples. Because everytype of data requires a different type of data compression process,conventional computing devices have to be preconfigured to perform datacompression on data types the device expects to handle. The number ofdifferent types of data may be prohibitive for conventional computingdevices to be configured to perform data compression on all types ofdata. For each type of data compression process a conventional computingdevice is configured to handle, the device requires additional resources(e.g. memory) and the complexity of configuring the device increases.

In contrast, a device 100 is can be configured to implement a quantizer1100 that enables to device to perform data compression or quantizationregardless of the data type of the original data sample. The quantizer1100 is able to convert higher order correlithm objects 104 into lowerorder correlithm objects 104 and vice-versa. By converting from a higherorder correlithm object 104 to a lower correlithm object 104 the node304 is able to represent data samples using fewer bits. Because thequantizer 1100 operates in the correlithm object domain, the quantizer1100 is agnostic to different data types. This means that the device 100is able to perform data compression without using different datacompression processes for every type of data. This reduces the overallcomplexity of the device configuration and reduces the amount ofresources (e.g. memory and processing time) necessary to perform datacompression.

The quantizer 1100 generally comprises a sensor 302, a node 304, and anactor 306. The quantizer 1100 may be configured with any suitable numberand/or configuration of sensors 302, nodes 304, and actors 306. Anexample of the quantizer 1100 in operation is described in FIG. 12. Inone embodiment, a sensor 302, a node 304, and an actor 306 may all beimplemented on the same device (e.g. user device 100). In otherembodiments, a sensor 302, a node 304, and an actor 306 may each beimplemented on different devices in signal communication with each otherfor example over a network. In other embodiments, different devices maybe configured to implement any combination of sensors 302, nodes 304,and actors 306.

The sensor 302 is configured as an interface that allows the user device100 to convert real world data samples into correlithm objects 104 thatcan be used in the correlithm object domain. The sensor 302 isconfigured to receive a real world value 1102 representing a data sampleas an input, to determine a correlithm object 104 based on the realworld value 1102, and to output the correlithm object 104. For example,the sensor 302 may receive an image of a person and output a correlithmobject 1104 to the node 304 or actor 306. In one embodiment, the sensor302 is configured to use sensor tables 308 that link a plurality of realworld values with a plurality of correlithm objects 104 in ann-dimensional space 102. In other examples, sensor tables 308 may beconfigured in any other suitable manner or may be implemented using anyother suitable data structure. In some embodiments, one or more mappingfunctions may be used to translate between a real world value and acorrelithm object 104 is a n-dimensional space 102.

The node 304 is configured to receive a child correlithm object 604(e.g. correlithm object 1104), to determine a parent correlithm object603 based on the received child correlithm object 604, and to output theidentified parent correlithm object 603 (e.g. correlithm object 1106).The node 304 is configured to use a node table 200 with stringcorrelithm objects 602 that link child correlithm objects 604 with theirrespective parent correlithm objects 603. The node table 200 may beconfigured similar to the node table 200 described in FIGS. 7 and 9. Byusing a node table 200 that comprises string correlithm objects 602, thenode 304 is able to convert between different orders of correlithmobjects 104. In other words, the node 304 is able to performquantization or data compression by converting higher order correlithmobjects 104 into lower order correlithm objects 104 and vice-versa. Byconverting from a higher order correlithm object 104 to a lowercorrelithm object 104 the node 304 is able to represent data samplesusing fewer bits.

The actor 306 serves as an interface that allows the user device 100 toconvert correlithm objects 104 in the correlithm object domain back toreal world values or data samples. The actor 306 is configured receive acorrelithm object 104 (e.g. quantized correlithm object 1106), todetermine a real world output value 1108 based on the receivedcorrelithm object 104, and to output the real world output value 1108.The real world output value 1108 is a quantized representation of theoriginal real world input value 1102. In other words, the real worldoutput value 1108 may use fewer bits to represent the original realworld input value 1102. In some embodiments, the real world output value1108 may be a different type or representation of the original datasample. In one embodiment, the actor 306 is configured to use actortables 310 that link a plurality of correlithm objects 104 in ann-dimensional space 102 with a plurality of real world values. As anexample, an actor table 310 may be configured with a first column thatlists correlithm objects 104 as output correlithm objects and a secondcolumn that lists real world values. In other examples, actor tables 310may be configured in any other suitable manner or may be implementedusing any other suitable data structure. In some embodiments, one ormore mapping functions may be employed to translate between a correlithmobject 104 in an n-dimensional space and a real world output value 1108.

FIG. 12 is a flowchart of another embodiment of a process 1200 foremulating a quantizer 1100 for a correlithm object processing system300. A user device 100 implements process 1200 to perform quantizationusing correlithm objects 104. The user device 100 uses process 1200 toconvert between different orders of correlithm objects 104. For example,the user device 100 may use process 1200 to convert between correlithmobjects 104 in a 128-dimensional space 102 and correlithm objects 104 ina 64-dimensional space 102.

As previously described above, the quantizer 1100 operates in thecorrelithm object domain and is agnostic to different data types. Thismeans that the device 100 emulating the quantizer 1100 is able toperform data compression without using different processes for everytype of data. This reduces the overall complexity of the deviceconfiguration and reduces the amount of resources (e.g. memory andprocessing time) necessary to perform data compression compared toconventional computing systems.

A non-limiting example is provided to illustrate how the device 100implements process 1200 to emulate a quantizer 1100 in a correlithmobject processing system 300 to convert from high order correlithmobjects 104 to lower order correlithm objects 104 which reduces the sizeof the bit strings that are used to represent the correlithm objects 104and the data samples.

At step 1202, the sensor 302 receives a real world input value 1102. Forexample, the sensor 302 receives an image of person's face as a realworld input value 1102. The real world input value 1102 may be in anysuitable data type or format. In one embodiment, the sensor 302 mayobtain the real world input value 1102 in real-time from a peripheraldevice (e.g. a camera). In another embodiment, the sensor 302 may obtainthe real world input value 1102 from a memory or database.

At step 1204, the sensor 302 identifies a real world value entry in asensor table 308 based on the real world input value 1102. In oneembodiment, the system 300 identifies a real world value entry in thesensor table 308 that matches the real world input value 1102. Forexample, the real world value entries may comprise previously storedimages. The sensor 302 may compare the received image to the previouslystored images to identify a real world value entry that matches thereceived image. In one embodiment, when the sensor 302 does not find anexact match, the sensor 302 finds a real world value entry that closestmatches the received image.

At step 1206, the sensor 302 identifies or fetches an input correlithmobject 104 in the sensor table 308 linked with the real world valueentry. At step 1208, the sensor 302 outputs the identified inputcorrelithm object 104. In one embodiment, the identified inputcorrelithm object 104 is represented in the sensor table 308 using acategorical binary integer string. The sensor 302 sends the binarystring representing to the identified input correlithm object 104 to thenode 304.

At step 1210, the node 304 computes distances between the inputcorrelithm object 104 and each child correlithm object 604 in a nodetable 200. In one embodiment, the distance 106 between the inputcorrelithm object 104 and a child correlithm object 604 can bedetermined based on the differences between the bits of the twocorrelithm objects. In other words, the distance 106 between the twocorrelithm objects can be determined based on how many individual bitsdiffer between the pair of correlithm objects. The distance 106 betweentwo correlithm objects 104 can be computed using hamming distance or anyother suitable technique. In another embodiment, the distance 106between two correlithm objects 104 can be determined using a Minkowskidistance such as the Euclidean or “straight-line” distance between thecorrelithm objects 104. For example, the distance 106 between a pair ofcorrelithm objects 104 may be determined by calculating the square rootof the sum of squares of the coordinate difference in each dimension.

At step 1212, the node 304 identifies a child correlithm object 604 fromthe node table 200 with the shortest distance. A child correlithm object604 with the shortest distance from the input correlithm object 104 isthe correlithm object that either matches or most closely matches thereceived input correlithm object 104.

At step 1214, the node 304 identifies or fetches a parent correlithmobject 603 in the node table 200 linked with the child correlithm object604. At step 1216, the node 304 outputs the identified parent correlithmobject 603. In this example, the identified parent correlithm object 603is represented in the node table 200 using a categorical binary integerstring. The node 304 sends the binary string representing to theidentified parent correlithm object 603 to the actor 306.

At step 1218, the actor 306 computes the distance between the parentcorrelithm object 603 and each output correlithm object 104 in an actortable 310. The actor 306 may compute the distances between the parentcorrelithm object 603 and each output correlithm object 104 in an actortable 310 using a process similar to the process described in step 1210.

At step 1220, the actor 306 identifies an output correlithm object 104from the actor table 310 with the shortest distance. An outputcorrelithm object 104 with the shortest distance from the parentcorrelithm object 603 is the correlithm object 104 that either matchesor most closely matches the received parent correlithm object 104.

At step 1222, the actor 306 identifies or fetches a real world outputvalue 1108 in the actor table 310 linked with the output correlithmobject 104. In one embodiment, the real world output value 1108corresponds with a quantized version of the original input signal. Forexample, the real world output value 1108 may be an image that isphysically smaller and/or an image that uses fewer bits, colors, pixels,etc. than the original image that was received by the correlithm objectprocessing system 300. In other embodiments, the real world output value1108 may be any suitable type of data sample that corresponds with aquantized version of the original input signal. The real world outputvalue 1108 may be in any suitable data type or format.

At step 1224, the actor 306 outputs the identified real world outputvalue 1108. In one embodiment, the actor 306 may output the real worldoutput value 1108 in real-time to a peripheral device (e.g. a display).In one embodiment, the actor 306 may output the real world output value1108 to a memory or database. In one embodiment, the real world outputvalue 1108 is sent to another sensor 302. For example, the real worldoutput value 1108 may be sent to another sensor 302 as an input foranother process.

FIGS. 13-18 generally describe correlithm object cores which can be usedby a correlithm object processing system 300 to classify or groupcorrelithm objects 104 and/or the data samples they represent. Acorrelithm object core identifies the class or type associated with theset of correlithm objects 104 and/or the data samples they represent.

Data that is processed by conventional computing devices does not haveany inherent classifications or grouping information associated with it.For example, a set of data that represents a bunch of images does notprovide any information that would allow a conventional computing deviceto automatically classify or group the images. The data for each imageappears as a random numeric value that is unrelated to other numericvalues that represent other images. As a result, conventional computingdevices require complex signal processing techniques to analyze theimages the data represents or a manual process for classifying orgrouping the data set. Using complex signal processing consumes asignificant amount of the device's resources (e.g. processing power andprocessing time). Using a manual process is slow, wastes processingresources, and is prone to human error.

In contrast, a device 100 is able to leverage to the categorical numbersused by a correlithm object processing system 300 to generate correlithmobject cores which allow the data samples to classified and grouptogether in the correlithm object domain. Using correlithm object cores,the device 100 is able to identify and classify similar types of datasamples. Because the device 100 is able to classify data samples in thecorrelithm object domain, the device 100 does not have to rely oncomplex signal processing nor does the device 100 have to be configuredto perform signal processing on a large number of different data types.This reduces the overall complexity of the device configuration andreduces the amount of resources (e.g. memory and processing time)necessary to perform identify and classify data samples compared toconventional computing systems.

FIG. 13 generally describes how a core distance may be defined for acorrelithm object core. FIGS. 14, 15A, and 15B describe embodiments foremulating a correlithm object core in a device 100. FIGS. 16 and 17generally describe examples of how correlithm object cores may interactwith other adjacent correlithm object cores. FIG. 18 describes anembodiment for how a device 100 can adjust the core distance for acorrelithm object core.

FIG. 13 is an embodiment of a graph of a probability distribution 1300for matching a random correlithm object 104 with a particular correlithmobject 104. Axis 1302 indicates the number of bits that are differentbetween a random correlithm object 104 with a particular correlithmobject 104. Axis 1304 indicates the probability associated with aparticular number of bits being different between a random correlithmobject 104 and a particular correlithm object 104.

As an example, FIG. 13 illustrates the probability distribution 1300 formatching correlithm objects 104 in a 64-dimensional space 102. In oneembodiment, the probability distribution 1300 is approximately aGaussian distribution. As the number of dimensions in the n-dimensionalspace 102 increases, the probability distribution 1300 starts to shapemore like an impulse response function. In other examples, theprobability distribution 1300 may follow any other suitable type ofdistribution.

Location 1306 illustrates an exact match between a random correlithmobject 104 with a particular correlithm object 104. As shown by theprobability distribution 1300, the probability of an exact match betweena random correlithm object 104 with a particular correlithm object 104is extremely low. In other words, when an exact match occurs the eventis most likely deliberate and not a random occurrence.

Location 1308 illustrates when all of the bits between the randomcorrelithm object 104 with the particular correlithm object 104 aredifferent. In this example, the random correlithm object 104 and theparticular correlithm object 104 have 64 bits that are different fromeach other. As shown by the probability distribution 1300, theprobability of all the bits being different between the randomcorrelithm object 104 and the particular correlithm object 104 is alsoextremely low.

Location 1310 illustrates an average number of bits that are differentbetween a random correlithm object 104 and the particular correlithmobject 104. In general, the average number of different bits between therandom correlithm object 104 and the particular correlithm object 104 isequal to

$\frac{n}{2},$where ‘n’ is the number of dimensions in the n-dimensional space 102. Inthis example, the average number of bits that are different between arandom correlithm object 104 and the particular correlithm object 104 is32 bits.

Location 1312 illustrates a cutoff region that defines a core distancefor a correlithm object core. The correlithm object 104 at location 1306may also be referred to as a root correlithm object for a correlithmobject core. The core distance defines the maximum number of bits thatcan be different between a correlithm object 104 and the root correlithmobject to be considered within a correlithm object core for the rootcorrelithm object. In other words, the core distance defines the maximumnumber of hops away a correlithm object 104 can be from a rootcorrelithm object to be considered a part of the correlithm object corefor the root correlithm object. Additional information about acorrelithm object core is described in FIG. 14. In this example, thecutoff region defines a core distance equal to six standard deviationsaway from the average number of bits that are different between a randomcorrelithm object 104 and the particular correlithm object 104. Ingeneral, the standard deviation is equal to

$\sqrt{\frac{n}{4}},$where ‘n’ is the number of dimensions in the n-dimensional space 102. Inthis example, the standard deviation of the 64-dimensional space 102 isequal to 4 bits. This means the cutoff region (location 1312) is located24 bits away from location 1310 which is 8 bits away from the rootcorrelithm object at location 1306. In other words, the core distance isequal to 8 bits. This means that the cutoff region at location 1312indicates that the core distance for a correlithm object core includescorrelithm objects 104 that have up to 8 bits different then the rootcorrelithm object or are up to 8 hops away from the root correlithmobject. In other examples, the cutoff region that defines the coredistance may be equal any other suitable value. For instance, the cutoffregion may be set to 2, 4, 8, 10, 12, or any other suitable number ofstandard deviations away from location 1310.

FIG. 14 is a schematic diagram of an embodiment of a device 100implementing a correlithm object core 1402 in a node 304 for acorrelithm object processing system 300. In other embodiments,correlithm object cores 1402 may be integrated with a sensor 302 or anactor 306. Correlithm object cores 1402 can be used by a correlithmobject processing system 300 to classify or group correlithm objects 104and/or the data samples they represent. For example, a set of correlithmobjects 104 can be grouped together by linking them with a correlithmobject core 1402. The correlithm object core 1202 identifies the classor type associated with the set of correlithm objects 104. An example ofa process for emulating or generating correlithm object cores 1402 isdescribed in FIGS. 15A and 15B.

In one embodiment, a correlithm object core 1402 comprises a rootcorrelithm object 1404 that is linked with a set of correlithm objects104. The set of correlithm objects 104 that are linked with the rootcorrelithm object 1404 are the correlithm objects 104 which are locatedwithin the core distance of the root correlithm object 1404. The set ofcorrelithm objects 104 are linked with only one root correlithm object1404. The core distance can be computed using a process similar to theprocess described in FIG. 13. For example, in a 64-dimensional space 102with a core distance defined at six sigma, the core distance is equal to8-bits. This means that correlithm objects 104 within up to eight hopsaway from the root correlithm object 1404 are members of the correlithmobject core 1402 for the root correlithm object 1404.

In one embodiment, a data structure such as node table 200 may be usedto map or link root correlithm objects 1404 with sets of correlithmobjects 104. The node table 200 is generally configured to identify aplurality of root correlithm objects 1404 and correlithm objects 104linked with the root correlithm objects 1404. For example, node table200 may be configured with a first column that lists correlithm objectcores 1402, a second column that lists root correlithm objects 1404, anda third column that lists correlithm objects 104. In other examples, thenode table 200 may be configured in any other suitable manner or may beimplemented using any other suitable data structure. In someembodiments, one or more mapping functions may be used to convertbetween correlithm objects 104 and a root correlithm object 1404.

FIG. 15A is a flowchart of an embodiment of a process 1500 for emulatinga correlithm object core 1402 in a node 304 for a correlithm objectprocessing system 300. Process 1500 provides instructions that allowsthe user device 100 to emulate or generate correlithm object cores 1402which can be used by a correlithm object processing system 300 forapplications that involve classifying or grouping correlithm objects 104and/or the data samples they represent.

A non-limiting example is provided to illustrate how the user device 100implements process flow 1500 to emulate or generate a correlithm objectcore 1402 for a correlithm object processing system 300. Process 1500may be applied or extended to a variety of applications that involveclassifying or grouping correlithm objects 104 and/or the data samplesthey represent.

At step 1502, the node 304 determines a core distance for a correlithmobject core 1202. The core distance may be determined using a processsimilar to the process described in FIG. 13.

At step 1504, the node 304 selects a correlithm object 104 in then-dimensional space 102. For example, the node 304 may randomly select acorrelithm object 104. As another example, the node 304 may select acorrelithm object 104 based on information provided (e.g. an identifier)by a user of the user device 100.

At step 1506, the node 304 sets the correlithm object 104 as a rootcorrelithm object 1404. In one embodiment, setting the correlithm object104 as the root correlithm object 1204 comprises adding an entry in anode table 200 that identifies the selected correlithm object 104 as aroot correlithm object 1404.

At step 1508, the node 304 identifies correlithm objects 104 within thecore distance from the root correlithm object 1204. For example, thenode 304 identifies any correlithm objects 104 that are within themaximum number of hops away from the root correlithm object 1404 asdefined by the core distance.

At step 1510, the node 304 links the identified correlithm objects 104with the root correlithm object 1404. In one embodiment, linking theidentified correlithm objects 104 with the root correlithm object 1404comprises adding an entry in the node table 200 that links thecorrelithm objects 104 with the root correlithm object 1404.

At step 1512, the node 304 determines whether to generate morecorrelithm object cores 1402. In one embodiment, the node 304 isconfigured to generate a predetermined number of correlithm object cores1402 and the node 304 determines whether the predetermined number ofcorrelithm object cores 1402 have been generated. In other embodiment,the node 304 prompts the user of the user device 100 whether or not togenerate additional correlithm object cores 1402 and determines whetherto generate additional correlithm object cores 1402 based on the usersfeedback or input. In other embodiments, the node 304 may determinewhether to generate more correlithm object cores 1402 based on any othertype of input or stimulus. The node 304 returns to step 1504 in responseto determining to generate more correlithm object cores 1402. In otherwords, the node 304 returns to step 1504 to continue generatingcorrelithm object cores 1402. The node 304 terminates process 1500 inresponse to determining to not generate anymore correlithm object cores1402.

FIG. 15B is a flowchart of another embodiment of a process 1550 foremulating a correlithm object core 1402 in a node 304 for a correlithmobject processing system 300. In this example, the node 304 determineswhether a correlithm object 104 is a member of a correlithm object 1402without previously identifying all of the members of the correlithmobject core 1402. Process 1550 may provide improved efficiency andperformance when the number of possible correlithm object 104 membersfor a correlithm object core 1402 is large.

At step 1552, the node 304 determines a core distance for a correlithmobject core 1202. The core distance may be determined using a processsimilar to the process described in FIG. 13.

At step 1554, the node 304 selects a correlithm object 104 in then-dimensional space 102. For example, the node 304 may randomly select acorrelithm object 104. As another example, the node 304 may select acorrelithm object 104 based on information provided (e.g. an identifier)by a user of the user device 100.

At step 1556, the node 304 sets the correlithm object 104 as a rootcorrelithm object 1404. In one embodiment, setting the correlithm object104 as the root correlithm object 1204 comprises adding an entry in anode table 200 that identifies the selected correlithm object 104 as aroot correlithm object 1404.

At step 1558, the node 304 receives a correlithm object 104. Forexample, the node 304 may receive a correlithm object identifier (e.g. abinary string) that identifies a particular correlithm object 104.

At step 1560, the node 304 determines the distance between the rootcorrelithm object 1404 and the received correlithm object 104. Forexample, the node 304 may determine the distance (e.g. hamming distance)between the root correlithm object 1404 and the correlithm object 104.The node 304 may determine the distance between the root correlithmobject 1404 and the received correlithm object 104 using any suitabletechnique.

At step 1562, the node 304 determines whether the distance between theroot correlithm object 1404 and the correlithm object 104 is less thanor equal to the core distance for the root correlithm object 1404. Inother words, the node 304 determines whether the correlithm object 104is within the core distance of the root correlithm object 1404. The node304 proceeds to step 1564 when the distance between the root correlithmobject 1404 and the correlithm object 104 is less than or equal to thecore distance for the root correlithm object 1404. The node 304 proceedsto step 1566 when the distance between the root correlithm object 1404and the correlithm object 104 is greater than the core distance for theroot correlithm object 1404.

At step 1564, the node 304 determines that the correlithm object 104 isa member of the correlithm object core 1402 associated with the rootcorrelithm object 1404 when the distance between the root correlithmobject 1404 and the correlithm object 104 is less than or equal to thecore distance for the root correlithm object 1404.

At step 1566, the node 304 determines that the correlithm object 104 isnot a member of the correlithm object core 1402 associated with the rootcorrelithm object 1404 when the distance between the root correlithmobject 1404 and the correlithm object 104 is greater than the coredistance for the root correlithm object 1404.

FIGS. 16 and 17 generally describe examples of how correlithm objectcores 1402 may interact with other adjacent correlithm object cores1402. More specifically, FIG. 16 provides an example where the coredistances of adjacent correlithm object cores 1402 do not overlap witheach other. FIG. 17 provides an example where the core distances ofadjacent correlithm object cores 1402 do overlap with each other.

FIG. 16 is an embodiment of a graph of probability distributions 1600for adjacent root correlithm objects 1404. Axis 1602 indicates thedistance between the root correlithm objects 1404, for example, in unitsof bits. Axis 1604 indicates the probability associated with the numberof bits being different between a random correlithm object 104 and aroot correlithm object 1404.

As an example, FIG. 16 illustrates the probability distributions foradjacent root correlithm objects 1404 in a 1024-dimensional space 102.Location 1606 illustrates the location of a first root correlithm object1404 with respect to a second root correlithm object 1404. Location 1608illustrates the location of the second root correlithm object 1404. Eachroot correlithm object 1404 is located an average distance away fromeach other which is equal to

$\frac{n}{2},$where ‘n’ is the number of dimensions in the n-dimensional space 102. Inthis example, the first root correlithm object 1404 and the second rootcorrelithm object 1404 are 512 bits or 32 standard deviations away fromeach other.

In this example, the cutoff region for each root correlithm object 1404is located at six standard deviations from locations 1606 and 1608. Inother examples, the cutoff region may be located at any other suitablelocation. For example, the cutoff region defining the core distance mayone, two, four, ten, or any other suitable number of standard deviationsaway from the average distance between correlithm objects 104 in then-dimensional space 102. Location 1610 illustrates a first cutoff regionthat defines a first core distance 1614 for the first root correlithmobject 1404. Location 1612 illustrates a second cutoff region thatdefines a second core distance 1616 for the second root correlithmobject 1404.

In this example, the core distances for the first root correlithm object1404 and the second root correlithm object 1404 do not overlap with eachother. This means that correlithm objects 104 within the correlithmobject core 1402 of one of the root correlithm objects 1404 are uniquelyassociated with the root correlithm object 1404 and there is noambiguity.

FIG. 17 is another embodiment of a graph of probability distributions1700 for adjacent root correlithm objects 1404. Axis 1702 indicates thedistance between the root correlithm objects 1404, for example, in unitsof standard deviations. Axis 1704 indicates the probability associatedwith the number of bits being different between a random correlithmobject 104 and a root correlithm object 1404.

As an example, FIG. 17 illustrates the probability distributions foradjacent root correlithm objects 1404 in a 64-dimensional space 102.Location 1706 illustrates the location of a first root correlithm object1404 with respect to a second root correlithm object 1404. Location 1708illustrates the location of the second root correlithm object 1404. Inthis example, the first root correlithm object 1404 and the second rootcorrelithm object 1404 are 32 bits or 8 standard deviations away fromeach other.

In this example, the cutoff region for each root correlithm object 1404is located six standard deviations away from locations 1706 and 1708. Inother examples, the cutoff region may be located at any other suitablelocation. Location 1710 illustrates a first cutoff region that defines afirst core distance 1716 for the first root correlithm object 1404.Location 1712 illustrates a second cutoff region that defines a secondcore distance 1718 for the second root correlithm object 1404.

In this example, the initial core distances for the first rootcorrelithm object 1404 and the second root correlithm object 1404overlap with each other. The first core distance 1710 is only twostandard deviations away from the second root correlithm object 1404.The overlapping core distances leads to ambiguity when determining whichcorrelithm object core 1402 a correlithm object 104 belongs to. Forinstance, a correlithm object 104 at location 1710 is within thecorrelithm object core 1402 for the first root correlithm object 1404,but it could also be noisy representation of the second root correlithmobject 1404 or a member of the correlithm object core 1402 for thesecond root correlithm object 1404. When core distances between adjacentcorrelithm object cores 1402 overlap it is difficult to correctlyassociate or identify correlithm objects 104.

Location 1714 illustrates a modified cutoff region that defines a newcore distance (e.g. core distances 1720 and 1722) for the first rootcorrelithm object 1404 and the second root correlithm object 1404. Themodified core distance is located at four standard deviations awaylocations 1706 and 1708. The modified core distance effectively movesthe cutoff region for each root correlithm object 1404 away fromadjacent root correlithm objects 1404. Adjusting the core distances inthis manner results in the core distances for the first root correlithmobject 1404 and the second root correlithm object 1404 no longeroverlapping and removes the ambiguity when determining which correlithmobject core 1402 a correlithm object 104 belongs to. An example of aprocess for modify the core distance between adjacent correlithm objectcores 1402 is described in FIG. 18.

FIG. 18 is a flowchart of another embodiment of a process 1800 foremulating a correlithm object core 1402 for a correlithm objectprocessing system 300. A non-limiting example is provided to illustratehow the user device 100 implements process flow 1800 to emulate orgenerate a correlithm object core 1402 for a correlithm objectprocessing system 300 where correlithm object cores 1402 may overlapwith other correlithm object cores 1402. For example, one or morecorrelithm object cores 1402 may already exist within an n-dimensionalspace 102 prior to generating a new correlithm object core 1402. Process1800 enables the user device 100 refine a generated correlithm objectcore 1402 to not overlap with other previously existing correlithmobject cores 1402.

At step 1802, the node determines a core distance for a correlithmobject core 1202. The core distance may be determined using a processsimilar to the process described in FIG. 13.

At step 1804, the node 304 selects a correlithm object in then-dimensional space 102. For example, the node 304 may randomly select acorrelithm object 104. As another example, the node 304 may select acorrelithm object 104 based on information provided (e.g. an identifier)by a user of the user device 100.

At step 1806, the node 304 sets the correlithm object 104 as a rootcorrelithm object 1404. In one embodiment, setting the correlithm object104 as the root correlithm object 1204 comprises adding an entry in anode table 200 that identifies the selected correlithm object 104 as aroot correlithm object 1404.

At step 1808, the node 304 identifies correlithm objects 104 within thecore distance from the root correlithm object 1204. For example, thenode 304 identifies any correlithm objects 104 that are within themaximum number of hops away from the root correlithm object 1404 asdefined by the core distance.

At step 1810, the node 304 determines whether any of the identifiedcorrelithm objects 104 are within the core distance of another rootcorrelithm object 1404. For example, the node 304 may determine whetherthe core distances between adjacent root correlithm objects 1404 overlapwith the core distance of the root correlithm object 1404. As anotherexample, the node 304 may determine whether any of the identifiedcorrelithm objects 104 are already members of other correlithm objectcores 1402 and/or linked with other root correlithm objects 1403. Forinstance, the node 304 may use a node table 200 to look-up whether anyof the correlithm objects 104 have been previously linked with anothercorrelithm object core 1402 and/or root correlithm object 1404.

The node 304 proceeds to step 1812 in response to determining that oneor more of the identified correlithm objects 104 is within the coredistance of another root correlithm object 1404. When one or more of theidentified correlithm objects 104 is within the core distance of anotherroot correlithm object 1404, the node 304 proceeds to step 1812 toadjust the core distance for the correlithm object core 1402. Adjustingthe core distance removes the ambiguity caused by overlapping coredistances. The node 304 proceeds to step 1814 in response to determiningthat none of the identified correlithm objects 104 are within the coredistance of another root correlithm object 1404.

At step 1812, the node 304 adjusts the core distance for the correlithmobject core 1402. In one embodiment, the node 304 adjusts the coredistance for the correlithm object core 1402 by reducing the coredistance. For example, the node 304 may determine the average distancebetween the root correlithm object 1404 and an adjacent root correlithmobject 1404 and set the core distance to half of the average distance.For instance, referring to FIG. 17, the average distance between theroot correlithm objects 1404 is eight standard deviations. The modifiedcore distance is set to four standard deviations which is equal to halfthe average distance between the root correlithm objects 1404. In otherembodiment, the node 304 may adjust the core distance for the correlithmobject core 1402 using any other suitable approach.

Returning to step 1810, the node 304 proceeds to step 1814 in responseto determining that none of the identified correlithm objects 104 arewithin the core distance of another root correlithm object 1404. At step1814, the node 304 links the identified correlithm objects 104 with theroot correlithm object 1404. In one embodiment, linking the identifiedcorrelithm objects 104 with the root correlithm object 1404 comprisesadding an entry in the node table 200 that identifies the correlithmobjects 104 associated with the root correlithm object 1404.

While several embodiments have been provided in the present disclosure,it should be understood that the disclosed systems and methods might beembodied in many other specific forms without departing from the spiritor scope of the present disclosure. The present examples are to beconsidered as illustrative and not restrictive, and the intention is notto be limited to the details given herein. For example, the variouselements or components may be combined or integrated in another systemor certain features may be omitted, or not implemented.

In addition, techniques, systems, subsystems, and methods described andillustrated in the various embodiments as discrete or separate may becombined or integrated with other systems, modules, techniques, ormethods without departing from the scope of the present disclosure.Other items shown or discussed as coupled or directly coupled orcommunicating with each other may be indirectly coupled or communicatingthrough some interface, device, or intermediate component whetherelectrically, mechanically, or otherwise. Other examples of changes,substitutions, and alterations are ascertainable by one skilled in theart and could be made without departing from the spirit and scopedisclosed herein.

To aid the Patent Office, and any readers of any patent issued on thisapplication in interpreting the claims appended hereto, applicants notethat they do not intend any of the appended claims to invoke 35 U.S.C. §112(f) as it exists on the date of filing hereof unless the words “meansfor” or “step for” are explicitly used in the particular claim.

The invention claimed is:
 1. A system to quantify a degree of similaritybetween different data samples having the same or different data typesand/or formats using correlithm objects, comprising: a device configuredto emulate string correlithm objects, the device comprising: a memory,operable to store: a node table that identifies a plurality ofcorrelithm objects comprising: a plurality of child correlithm objects,wherein each child correlithm object is a point in a first n-dimensionalspace represented by a binary string; and a plurality of parentcorrelithm objects, wherein: each parent correlithm object is a point ina second n-dimensional space represented by a binary string; and eachparent correlithm object is linked with two or more child correlithmobjects from among the plurality of child correlithm objects; wherein:the first n-dimensional space has a greater number of dimensions thanthe second n-dimensional space; the first n-dimensional space isembedded in the second n-dimensional space; and each parent correlithmobject is a standard distance away from other parent correlithm objects;and a node implemented by one or more processors configured to: define anumber of child correlithm objects for a string correlithm object;select a starting correlithm object from the second n-dimensional space;set the starting correlithm object as a first parent correlithm object;select an ending correlithm object from the second n-dimensional space;set the ending correlithm object as a second parent correlithm object;iteratively identify a first portion of the defined number of childcorrelithm objects, wherein identifying the first portion of the definednumber of child correlithm objects comprises: randomly selecting a firstcorrelithm object less than the standard distance away from the firstparent correlithm object; and defining the selected first correlithmobject as a first child correlithm object, wherein the first childcorrelithm object represents data of a first data type; link the firstportion of the defined number of child correlithm objects with the firstparent correlithm object in the node table; iteratively identify asecond portion of the defined number of child correlithm objects,wherein identifying the second portion of the defined number of childcorrelithm objects comprises: randomly selecting a second correlithmobject less than the standard distance away from the second parentcorrelithm object; and defining the selected second correlithm object asa second child correlithm object, wherein the second child correlithmobject represents data of a second data type that is different from thefirst data type; and link the second portion of the defined number ofchild correlithm objects with the second parent correlithm object in thenode table; wherein the device quantifies a degree of similarity between(a) different data samples having the same or different data typesand/or formats, (b) different facial images, or (c) different images ofpeople, by: using the results of the emulation performed by the node;computing n-dimensional distances between data samples; and performingnon-binary comparisons between data samples using categorical numbers;wherein the degree of similarity indicates how similar the differentdata samples are to each other.
 2. The system of claim 1, wherein thefirst portion of the defined child correlithm objects and the secondportion of the defined child correlithm objects do not form a loop. 3.The system of claim 1, wherein: linking the first portion of the definednumber of child correlithm objects with the first parent correlithmobject comprises adding the first portion of the defined number of childcorrelithm objects and the first parent correlithm object to the nodetable; and linking the second portion of the defined number of childcorrelithm objects with the second parent correlithm object comprisesadding the second portion of the defined number of child correlithmobjects and the second parent correlithm object to the node table. 4.The system of claim 1, wherein: each child correlithm object in thedefined number child correlithm objects is a fractional distance awayfrom at least one other child correlithm object in the defined number ofchild correlithm objects; and the fractional distance is less than thestandard distance between parent correlithm objects.
 5. The system ofclaim 1, wherein at least one of the first parent correlithm object andthe second parent correlithm object is linked with two or more sets ofchild correlithm objects.
 6. The system of claim 1, wherein each of theplurality of child correlithm objects in the node table is only linkedwith one parent correlithm object.
 7. The system of claim 1, wherein thefirst portion of the defined number of child correlithm objects is equalto half of the defined number of child correlithm objects.
 8. A methodto quantify a degree of similarity between different data samples havingthe same or different data types and/or formats using correlithmobjects, comprising: emulating string correlithm objects by defining, bya node implemented by one or more processors, a number of childcorrelithm objects for a string correlithm object, wherein each childcorrelithm object is a point in a first n-dimensional space representedby a binary string; selecting, by the node, a starting correlithm objectfrom a second n-dimensional space, wherein: the first n-dimensionalspace has a greater number of dimensions than the second n-dimensionalspace; and the first n-dimensional space is embedded in the secondn-dimensional space; setting, by the node, the starting correlithmobject as a first parent correlithm object, wherein: each parentcorrelithm object is a point in the second n-dimensional spacerepresented by a binary string; and each parent correlithm object islinked with two or more child correlithm objects; selecting, by thenode, an ending correlithm object from the second n-dimensional space;setting, by the node, the ending correlithm object as a second parentcorrelithm object; iteratively identifying, by the node, a first portionof the defined number of child correlithm objects, wherein identifyingthe first portion of the defined number of child correlithm objectscomprises: randomly selecting a first correlithm object less than thestandard distance away from the first parent correlithm object; anddefining the selected first correlithm object as a first childcorrelithm object, wherein the first child correlithm object representsdata of a first data type; linking, by the node, the first portion ofthe defined number of child correlithm objects with the first parentcorrelithm object in a node table, wherein the node table identifies aplurality of parent correlithm objects and a plurality of childcorrelithm objects; iteratively identifying, by the node, a secondportion of the defined number of child correlithm objects, whereinidentifying the second portion of the defined number of child correlithmobjects comprises: randomly selecting a second correlithm object lessthan the standard distance away from the second parent correlithmobject; and defining the selected second correlithm object as a secondchild correlithm object, wherein the second child correlithm objectrepresents data of a second data type different from the first datatype; and linking, by the node, the second portion of the defined numberof child correlithm objects with the second parent correlithm object inthe node table; and quantifying a degree of similarity between (a)different data samples having the same or different data types and/orformats, (b) different facial images, or (c) different images of people,by: using the results of the emulation performed by the node; computingn-dimensional distances between data samples; and performing non-binarycomparisons between data samples using categorical numbers; wherein thedegree of similarity indicates how similar the different data samplesare to each other.
 9. The method of claim 8, wherein the first portionof the defined child correlithm objects and the second portion of thedefined child correlithm objects do not form a loop.
 10. The method ofclaim 8, wherein: linking the first portion of the defined number ofchild correlithm objects with the first parent correlithm objectcomprises adding the first portion of the defined number of childcorrelithm objects and the first parent correlithm object to the nodetable; and linking the second portion of the defined number of childcorrelithm objects with the second parent correlithm object comprisesadding the second portion of the defined number of child correlithmobjects and the second parent correlithm object to the node table. 11.The method of claim 8, wherein: each child correlithm object in thedefined number child correlithm objects is a fractional distance awayfrom at least one other child correlithm object in the defined number ofchild correlithm objects; and the fractional distance is less than thestandard distance between parent correlithm objects.
 12. The method ofclaim 8, wherein at least one of the first parent correlithm object andthe second parent correlithm object is linked with two or more sets ofchild correlithm objects.
 13. The method of claim 8, wherein each of theplurality of child correlithm objects in the node table is only linkedwith one parent correlithm object.
 14. The method of claim 8, whereinthe first portion of the defined number of child correlithm objects isequal to half of the defined number of child correlithm objects.
 15. Acomputer program product comprising executable instructions stored in anon-transitory computer readable medium that when executed by aprocessor is configured to: emulate string correlithm objects by:defining a number of child correlithm objects for a string correlithmobject, wherein each child correlithm object is a point in a firstn-dimensional space represented by a binary string; selecting a startingcorrelithm object from a second n-dimensional space, wherein: the firstn-dimensional space has a greater number of dimensions than the secondn-dimensional space; and the first n-dimensional space is embedded inthe second n-dimensional space; setting the starting correlithm objectas a first parent correlithm object, wherein: each parent correlithmobject is a point in the second n-dimensional space represented by abinary string; and each parent correlithm object is linked with two ormore child correlithm objects; selecting an ending correlithm objectfrom the second n-dimensional space; setting the ending correlithmobject as a second parent correlithm object; iteratively identifying afirst portion of the defined number of child correlithm objects, whereinidentifying the first portion of the defined number of child correlithmobjects comprises: randomly selecting a first correlithm object lessthan the standard distance away from the first parent correlithm object;and defining the selected first correlithm object as a first childcorrelithm object, wherein the first child correlithm object representsdata of a first data type; linking the first portion of the definednumber of child correlithm objects with the first parent correlithmobject in a node table, wherein the node table identifies a plurality ofparent correlithm objects and a plurality of child correlithm objects;iteratively identifying a second portion of the defined number of childcorrelithm objects, wherein identifying the second portion of thedefined number of child correlithm objects comprises: randomly selectinga second correlithm object less than the standard distance away from thesecond parent correlithm object; and defining the selected secondcorrelithm object as a second child correlithm object, wherein thesecond child correlithm object represents data of a second data typedifferent from the first data type; and linking the second portion ofthe defined number of child correlithm objects with the second parentcorrelithm object in the node table; and quantify a degree of similaritybetween (a) different data samples having the same or different datatypes and/or formats, (b) different facial images, or (c) differentimages of people, by: using the results of the emulation; computingn-dimensional distances between data samples; and performing non-binarycomparisons between data samples using categorical numbers; wherein thedegree of similarity indicates how similar the different data samplesare to each other.
 16. The computer program product of claim 15, whereinthe first portion of the defined child correlithm objects and the secondportion of the defined child correlithm objects do not form a loop. 17.The computer program product of claim 15, wherein: linking the firstportion of the defined number of child correlithm objects with the firstparent correlithm object comprises adding the first portion of thedefined number of child correlithm objects and the first parentcorrelithm object to the node table; and linking the second portion ofthe defined number of child correlithm objects with the second parentcorrelithm object comprises adding the second portion of the definednumber of child correlithm objects and the second parent correlithmobject to the node table.
 18. The computer program product of claim 15,wherein at least one of the first parent correlithm object and thesecond parent correlithm object is linked with two or more sets of childcorrelithm objects.
 19. The computer program product of claim 15,wherein each of the plurality of child correlithm objects in the nodetable is only linked with one parent correlithm object.
 20. The computerprogram product of claim 15, wherein the first portion of the definednumber of child correlithm objects is equal to half of the definednumber of child correlithm objects.